model_training_reduced.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Model training"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Import libraries"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The following command must be executed for balancing:\n",
    "\n",
    "```conda install -c conda-forge imbalanced-learn```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "from enum import Enum\n",
    "import math\n",
    "import win32com.client as win32\n",
    "\n",
    "from sklearn.model_selection import StratifiedKFold\n",
    "from sklearn.model_selection import GridSearchCV\n",
    "from sklearn.model_selection import train_test_split\n",
    "from sklearn.model_selection import learning_curve\n",
    "from sklearn.metrics import accuracy_score, f1_score, recall_score, precision_score, roc_curve, fbeta_score, make_scorer\n",
    "from sklearn.dummy import DummyClassifier\n",
    "from sklearn.neighbors import KNeighborsClassifier\n",
    "from sklearn.ensemble import RandomForestClassifier\n",
    "from sklearn.linear_model import LogisticRegression\n",
    "from sklearn.svm import SVC\n",
    "from sklearn.neural_network import MLPClassifier\n",
    "from sklearn.ensemble import GradientBoostingClassifier\n",
    "\n",
    "import pandas as pd\n",
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "import statsmodels.api as sm\n",
    "from scipy import stats\n",
    "from imblearn.over_sampling import RandomOverSampler\n",
    "\n",
    "outlook = win32.Dispatch('outlook.application')\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Tensorflow may not be installed on every system\n",
    "import tensorflow as tf\n",
    "from scikeras.wrappers import KerasClassifier"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Methods"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "def truncate(number, digits) -> float:\n",
    "    # Helper method that truncate scores to four decimals\n",
    "    nbDecimals = len(str(number).split('.')[1])\n",
    "    if nbDecimals <= digits:\n",
    "        return number\n",
    "    stepper = 10.0 ** digits\n",
    "    return math.trunc(stepper * number) / stepper\n",
    "\n",
    "\n",
    "def get_nested(data, *args):\n",
    "    # Helper method that returns the value of a nested dictionary\n",
    "    if args and data:\n",
    "        element  = args[0]\n",
    "        if element:\n",
    "            value = data.get(element)\n",
    "            return value if len(args) == 1 else get_nested(value, *args[1:])\n",
    "    return None\n",
    "\n",
    "\n",
    "def get_scores(y_test, y_predicted):\n",
    "    # Method that returns different scores for the passed parameters\n",
    "    digits = 4\n",
    "    scores = {\n",
    "        'Accuracy': truncate(accuracy_score(y_test, y_predicted), digits),\n",
    "        'Recall': truncate(recall_score(y_test, y_predicted), digits),\n",
    "        'Precision': truncate(precision_score(y_test, y_predicted), digits),\n",
    "        'F1 score': truncate(f1_score(y_test, y_predicted), digits),\n",
    "        'F2 score': truncate(fbeta_score(y_test, y_predicted, beta=2), digits)\n",
    "    }\n",
    "    return scores\n",
    "\n",
    "\n",
    "def print_scores(all_scores):\n",
    "    # Method that prints a table of the passed scores\n",
    "    header_row = \"{header:<20}\".format(header=\"Estimator\")\n",
    "    for score in list(all_scores.values())[0]:\n",
    "        header_row+=\"{header:>15}\".format(header=score)\n",
    "    print(header_row,\"\\n\")\n",
    "\n",
    "    for estimator in all_scores.keys():\n",
    "        current_row = \"{estimator:<20}\".format(estimator=estimator)\n",
    "        estimator_scores = all_scores.get(estimator)\n",
    "        for score in estimator_scores:\n",
    "            score_value = get_nested(all_scores, estimator, score)\n",
    "            current_row+=\"{score_value:>15}\".format(score_value=score_value)\n",
    "        print(current_row)\n",
    "        \n",
    "\n",
    "def print_best_params(estimator_params):\n",
    "    # Method that prints the best parameters\n",
    "    for estimator in estimator_params.keys():\n",
    "        print(\"Best parameters for \"+estimator+\": \")\n",
    "        parameters = estimator_params.get(estimator)\n",
    "        for parameter in parameters:\n",
    "            print(parameter+\": \"+str(get_nested(estimator_params, estimator, parameter)))\n",
    "            \n",
    "\n",
    "def plot_roc(title, ax, y_test, y_predicted):\n",
    "    # Method that plots the ROC for the passed parameters\n",
    "    false_positive_rate, true_positive_rate, threshold = roc_curve(y_test, y_predicted)\n",
    "    ax.plot(false_positive_rate, true_positive_rate)\n",
    "    ax.plot([0, 1], ls=\"--\")\n",
    "    ax.plot([0, 0], [1, 0] , c=\".7\"), plt.plot([1, 1] , c=\".7\")\n",
    "\n",
    "    ax.set_title('Receiver Operating Characteristic (ROC) - '+title)\n",
    "    ax.set_ylabel('True Positive Rate')\n",
    "    ax.set_xlabel('False Positive Rate')\n",
    "    \n",
    "\n",
    "def plot_feature_importance(title, ax, estimator, X_train):\n",
    "    # Method that plots the feature importance for the passed parameters\n",
    "    feat_importance = pd.Series(estimator.feature_importances_, index=X_train.columns)\n",
    "    feat_importance.nlargest(12).plot(kind='barh', ax=ax)\n",
    "\n",
    "    ax.set_title('Feature Importance for '+title)\n",
    "\n",
    "\n",
    "def plot_learning_curve(title, estimator, ax, X, y, cv, scoring=None):\n",
    "    # Method that plots the learning curve for the passed parameters\n",
    "    train_sizes, train_scores, test_scores, fit_times, _ = learning_curve(\n",
    "        estimator,\n",
    "        X,\n",
    "        y,\n",
    "        scoring=scoring,\n",
    "        cv=cv,\n",
    "        n_jobs=4,\n",
    "        train_sizes=np.linspace(0.1, 1.0, 5),\n",
    "        return_times=True,\n",
    "    )\n",
    "    train_scores_mean = np.mean(train_scores, axis=1)\n",
    "    train_scores_std = np.std(train_scores, axis=1)\n",
    "    test_scores_mean = np.mean(test_scores, axis=1)\n",
    "    test_scores_std = np.std(test_scores, axis=1)\n",
    "\n",
    "    ax.grid()\n",
    "    ax.fill_between(\n",
    "        train_sizes,\n",
    "        train_scores_mean - train_scores_std,\n",
    "        train_scores_mean + train_scores_std,\n",
    "        alpha=0.1,\n",
    "        color=\"r\",\n",
    "    )\n",
    "    ax.fill_between(\n",
    "        train_sizes,\n",
    "        test_scores_mean - test_scores_std,\n",
    "        test_scores_mean + test_scores_std,\n",
    "        alpha=0.1,\n",
    "        color=\"g\",\n",
    "    )\n",
    "    ax.plot(train_sizes, train_scores_mean, \"o-\", color=\"r\", label=\"Training score\")\n",
    "    ax.plot(train_sizes, test_scores_mean, \"o-\", color=\"g\", label=\"Cross-validation score\")\n",
    "\n",
    "    ax.set_title(\"Learning Curve: \"+title)\n",
    "    ax.set_xlabel(\"Training examples\")\n",
    "    ax.set_ylabel(\"Score\")\n",
    "    ax.legend()\n",
    "    \n",
    "    \n",
    "def plot_loss(title, history):\n",
    "    # list all data in history\n",
    "    print(history.history.keys())\n",
    "    # summarize history for recall\n",
    "    for metric in history.history.keys():\n",
    "        if not str(metric).startswith(\"val\"):\n",
    "            plt.plot(history.history[metric])\n",
    "            plt.plot(history.history['val_'+metric])\n",
    "            plt.title(title + 'model ' + metric)\n",
    "            plt.ylabel(metric)\n",
    "            plt.xlabel('epoch')\n",
    "            plt.legend(['train', 'validation'], loc='upper left')\n",
    "            plt.show()\n",
    "\n",
    "\n",
    "def send_mail_via_outlook(message:str):\n",
    "    mail = outlook.CreateItem(0)\n",
    "    mail.To = 'florian.v.lang@gmx.de'\n",
    "    mail.Subject = 'Estimator done!'\n",
    "    mail.Body = message\n",
    "    #mail.HTMLBody = '<h2>HTML Message body</h2>' #this field is optional\n",
    "    # To attach a file to the email (optional):\n",
    "    # attachment  = \"Path to the attachment\"\n",
    "    # mail.Attachments.Add(attachment)\n",
    "    mail.Send()\n",
    "        \n",
    "\n",
    "def model_evaluate(estimator, parameters, X_train, X_test, y_train, y_test, cv_folds=2, n_jobs=-1, do_send_notification_mail=False):\n",
    "    # Method that trains the passed model with the passed parameters and plots the evaluation of it\n",
    "    scoring = make_scorer(fbeta_score, beta=2)\n",
    "\n",
    "    # create the grid search instance\n",
    "    grid_search_estimator = GridSearchCV(estimator=estimator.value,\n",
    "                                         param_grid=parameters,\n",
    "                                         scoring= scoring,\n",
    "                                         cv=cv_folds,\n",
    "                                         return_train_score=True,\n",
    "                                         verbose=3,\n",
    "                                         n_jobs=n_jobs\n",
    "                                         )\n",
    "    # training and prediction\n",
    "    fitted_estimator_grid = grid_search_estimator.fit(X_train, y_train)\n",
    "    best_fitted_estimator = fitted_estimator_grid.best_estimator_\n",
    "    y_predicted = fitted_estimator_grid.predict(X_test)\n",
    "    \n",
    "    # evaluation of the model\n",
    "    print_scores({estimator.name: get_scores(y_test, y_predicted)})\n",
    "    print_best_params({estimator.name: fitted_estimator_grid.best_params_})\n",
    "\n",
    "    figure = plt.figure(figsize=(15, 15))\n",
    "    figure_index = 1\n",
    "    number_of_rows = 2\n",
    "    number_of_columns = 2\n",
    "    \n",
    "    # plot roc\n",
    "    ax = figure.add_subplot(number_of_rows, number_of_columns, figure_index)\n",
    "    plot_roc(title=estimator.name, ax=ax, y_test=y_test, y_predicted=y_predicted)\n",
    "    figure_index += 1\n",
    "    \n",
    "    # plot feature importance in case of forest estimator\n",
    "    if estimator==Estimator.forest_estimator:\n",
    "        ax = figure.add_subplot(number_of_rows, number_of_columns, figure_index)\n",
    "        plot_feature_importance(title=estimator.name, ax=ax, estimator=fitted_estimator_grid.best_estimator_, X_train=X_train)\n",
    "        figure_index += 1\n",
    "        \n",
    "    if estimator==Estimator.log_regr_estimator:\n",
    "        headers = [\"Coefficient\", \"value\"]\n",
    "        print_template = \"\"\n",
    "        for i in range(len(headers)):\n",
    "            k = len(headers[i])\n",
    "            print_template += \"{\" + str(i) + \":\" + str(k+5) + \"}|\"\n",
    "        print(print_template.format(*headers))\n",
    "        print(print_template.format(\"intercept\", best_fitted_estimator.intercept_[0]))\n",
    "        i = 0\n",
    "        for coef in best_fitted_estimator.coef_[0]:\n",
    "            feature_name = best_fitted_estimator.feature_names_in_[i]\n",
    "            print(print_template.format(feature_name, round(coef, 5)))\n",
    "            i += 1\n",
    "    plt.show()\n",
    "    \n",
    "    if do_send_notification_mail:\n",
    "        send_mail_via_outlook(\"The estimator {} was fitted with params: {}\".format(estimator.name, fitted_estimator_grid.best_params_))\n",
    "        \n",
    "    return fitted_estimator_grid"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Setup data\n",
    "\n",
    "Load preprocessed dataset and create objects X and y to store the data and the target value. Then split data into training data and testing data."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Index(['HeartDisease', 'AlcoholDrinking', 'Stroke', 'DiffWalking', 'Sex',\n",
      "       'AgeCategory', 'Diabetic', 'PhysicalActivity', 'KidneyDisease',\n",
      "       'SkinCancer', 'breathing_risk', 'BMI_sqrt', 'GenHealth_squared',\n",
      "       'GenHealth_squared_x_Age', 'GenHealth_squared_x_PhysicalHealth',\n",
      "       'PhysicalHealth__x_DiffWalking', 'PhysicalHealth_binned'],\n",
      "      dtype='object')\n",
      "Size of dataset: 319795\n"
     ]
    }
   ],
   "source": [
    "# choose parameters\n",
    "use_reduced_ds = True\n",
    "use_sample = False\n",
    "\n",
    "# Load dataset\n",
    "if use_reduced_ds:\n",
    "    heart_dataset = pd.read_csv('./heart_dataset_preprocessed_reduced.csv')\n",
    "else:\n",
    "    heart_dataset = pd.read_csv('./heart_dataset_preprocessed.csv')\n",
    "print(heart_dataset.columns)\n",
    "if use_sample:\n",
    "    sample_size = 30000\n",
    "    selected_data = heart_dataset.sample(n=sample_size, random_state=3)\n",
    "else:\n",
    "    selected_data = heart_dataset\n",
    "print(\"Size of dataset: {}\".format(heart_dataset.shape[0]))\n",
    "# Split and reduce dataset (reduction only for test purposes)\n",
    "X = selected_data.drop(columns='HeartDisease')\n",
    "y = selected_data['HeartDisease']\n",
    "\n",
    "X_train, X_test, y_train, y_test = train_test_split(X, y, test_size = 0.2, random_state = 42, stratify=y)\n",
    "\n",
    "# Balance training data\n",
    "X_train_oversampled, y_train_oversampled = RandomOverSampler().fit_resample(X_train, y_train)\n",
    "\n",
    "data_dict = {\"X_train\": X_train, \"X_test\": X_test, \"y_train\": y_train, \"y_test\": y_test}\n",
    "data_dict_oversampled = {\"X_train\": X_train_oversampled, \"X_test\": X_test, \"y_train\": y_train_oversampled, \"y_test\": y_test}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Baseline\n",
    "\n",
    "We define a baseline model as a reference to the actual model with DummyClassifier from Scikit-Learn. Because our data is very imbalanced, we are using the stratified strategy."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Estimator                  Accuracy         Recall      Precision       F1 score       F2 score \n",
      "\n",
      "Dummy Classifier             0.8415         0.0814         0.0803         0.0809         0.0812\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 576x576 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "dummy_classifier = DummyClassifier(strategy='stratified')\n",
    "dummy_classifier.fit(X_train, y_train)\n",
    "y_predicted = dummy_classifier.predict(X_test)\n",
    "\n",
    "print_scores({'Dummy Classifier':get_scores(y_test, y_predicted)})\n",
    "plot_roc(title='Baseline', ax=plt.figure(figsize=(8, 8)).add_subplot(), y_test=y_test, y_predicted=y_predicted)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Conclusion**\n",
    "\n",
    "We achieve an 0.84 accuracy, a 0.09 recall, a 0.09 precision and a 0.09 F1-Score. Plotting the ROC curve shows that the baseline classifier is not really better than a random classifier\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Model selection\n",
    "\n",
    "To find out which modeling method with which parameters best fits to our task, we define a set of modeling methods, train them with different parameters (hyperparameter tuning) and evaluate the results."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Create DNN model\n",
    "def create_model(dropout_rate, hidden_layer_sizes=(20, 20), activation='relu'):\n",
    "    # create model\n",
    "    model = tf.keras.models.Sequential()\n",
    "    model.add(tf.keras.layers.Input(shape=(X_train.columns.size,)))\n",
    "    \n",
    "    for hidden_layer_size in hidden_layer_sizes:\n",
    "        model.add(tf.keras.layers.Dense(hidden_layer_size, activation=activation))\n",
    "    \n",
    "    model.add(tf.keras.layers.Dropout(dropout_rate))\n",
    "    model.add(tf.keras.layers.Dense(1, activation='sigmoid'))\n",
    "              \n",
    "    return model\n",
    "\n",
    "# Enumeration class containing all estimators we want to consider for classification\n",
    "class Estimator(Enum):\n",
    "    knn_estimator=KNeighborsClassifier()\n",
    "    forest_estimator=RandomForestClassifier(random_state=42)\n",
    "    svc_estimator=SVC(random_state=42)\n",
    "    log_regr_estimator=LogisticRegression(random_state=42)\n",
    "    dnn_estimator=KerasClassifier(model=create_model, verbose=0, hidden_layer_sizes=(30, 30), activation='sigmoid', dropout_rate=0.0)\n",
    "    xgb_estimator=GradientBoostingClassifier(random_state=42)\n",
    "\n",
    "# Class Weights calculation\n",
    "neg, pos = np.bincount(y_train)\n",
    "total = neg + pos\n",
    "\n",
    "weight_for_0 = (1 / neg) * (total / 2.0)\n",
    "weight_for_1 = (1 / pos) * (total / 2.0)\n",
    "\n",
    "# Dictionary of parameter grids of the estimators\n",
    "weights_ls = [{0:1, 1:1}, {0:1, 1:4}, {0: weight_for_0, 1: weight_for_1}]\n",
    "n_estimators_ls_tree_models = [50, 100, 200, 800, 1000]\n",
    "max_features_ls_tree_models = ['sqrt', 'log2']\n",
    "validation_fraction_tree_models = [0.3]\n",
    "n_iter_no_change_tree_models = [50]\n",
    "\n",
    "param_grids = {\n",
    "    Estimator.knn_estimator: {\n",
    "        'n_neighbors': [2, 3, 4, 5]\n",
    "    },\n",
    "    Estimator.forest_estimator: {\n",
    "        'class_weight': weights_ls,\n",
    "        'n_estimators': n_estimators_ls_tree_models, \n",
    "        'max_features': max_features_ls_tree_models,\n",
    "        'min_samples_split': [10],\n",
    "        'max_samples': [1000, None],\n",
    "        'n_jobs': [-1]\n",
    "    },\n",
    "    Estimator.svc_estimator: {\n",
    "        'kernel': ['linear', 'poly', 'rbf', 'sigmoid'],\n",
    "        'class_weight': weights_ls\n",
    "    },\n",
    "    Estimator.dnn_estimator: {\n",
    "        'batch_size': [512],\n",
    "        'epochs': [100, 300],\n",
    "        'hidden_layer_sizes': [(20,20), (60,30), (40,20,10)],\n",
    "        'activation': ['relu'],\n",
    "        'loss': ['binary_crossentropy'],\n",
    "        'optimizer': ['SGD', 'adam'],\n",
    "        'class_weight': weights_ls,\n",
    "        'dropout_rate': [0.4]\n",
    "    },\n",
    "    Estimator.xgb_estimator: {\n",
    "        'n_estimators': n_estimators_ls_tree_models,\n",
    "        'loss': ['log_loss'], # like advised in scikit-learn documentation\n",
    "        'criterion': ['friedman_mse'], # like advised in scikit-learn documentation\n",
    "        'max_depth': [3, 5, 10, 20],\n",
    "        'max_features': max_features_ls_tree_models,\n",
    "        'max_leaf_nodes': [5, 10, None],\n",
    "        'validation_fraction': validation_fraction_tree_models,\n",
    "        'n_iter_no_change': n_iter_no_change_tree_models\n",
    "    },\n",
    "    Estimator.log_regr_estimator: {\n",
    "        'solver': ['sag', 'saga', 'lbfgs'], # TODO check also saga with elasticnet\n",
    "        'max_iter': [200, 400, 1000], \n",
    "        'class_weight': weights_ls\n",
    "    }\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Fitting 2 folds for each of 36 candidates, totalling 72 fits\n",
      "Estimator                  Accuracy         Recall      Precision       F1 score       F2 score \n",
      "\n",
      "dnn_estimator                0.7151          0.821         0.2068         0.3304          0.515\n",
      "Best parameters for dnn_estimator: \n",
      "activation: relu\n",
      "batch_size: 512\n",
      "class_weight: {0: 0.5468029990852277, 1: 5.841538040003653}\n",
      "dropout_rate: 0.4\n",
      "epochs: 300\n",
      "hidden_layer_sizes: (60, 30)\n",
      "loss: binary_crossentropy\n",
      "optimizer: SGD\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1080x1080 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# dnn estimator\n",
    "estimator = Estimator.dnn_estimator\n",
    "grid = model_evaluate(estimator, param_grids.get(estimator), **data_dict)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Fitting 2 folds for each of 120 candidates, totalling 240 fits\n",
      "Estimator                  Accuracy         Recall      Precision       F1 score       F2 score \n",
      "\n",
      "xgb_estimator                0.8535         0.3052         0.2309         0.2629         0.2867\n",
      "Best parameters for xgb_estimator: \n",
      "criterion: friedman_mse\n",
      "loss: log_loss\n",
      "max_depth: 20\n",
      "max_features: sqrt\n",
      "max_leaf_nodes: None\n",
      "n_estimators: 100\n",
      "n_iter_no_change: 50\n",
      "validation_fraction: 0.3\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1500x1500 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# XGBoost estimator\n",
    "estimator = Estimator.xgb_estimator\n",
    "grid = model_evaluate(estimator, param_grids.get(estimator), **data_dict_oversampled)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Fitting 2 folds for each of 4 candidates, totalling 8 fits\n",
      "Estimator                  Accuracy         Recall      Precision       F1 score       F2 score \n",
      "\n",
      "knn_estimator                0.8426         0.3817         0.2383         0.2934         0.3407\n",
      "Best parameters for knn_estimator: \n",
      "n_neighbors: 3\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1500x1500 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [
       "<style>#sk-container-id-1 {color: black;background-color: white;}#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>GridSearchCV(cv=2, estimator=KNeighborsClassifier(), n_jobs=12,\n",
       "             param_grid={&#x27;n_neighbors&#x27;: [2, 3, 4, 5]}, return_train_score=True,\n",
       "             scoring=make_scorer(fbeta_score, beta=2), verbose=3)</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 sk-dashed-wrapped\"><div class=\"sk-label-container\"><div class=\"sk-label sk-toggleable\"><input class=\"sk-toggleable__control sk-hidden--visually\" id=\"sk-estimator-id-1\" type=\"checkbox\" ><label for=\"sk-estimator-id-1\" class=\"sk-toggleable__label sk-toggleable__label-arrow\">GridSearchCV</label><div class=\"sk-toggleable__content\"><pre>GridSearchCV(cv=2, estimator=KNeighborsClassifier(), n_jobs=12,\n",
       "             param_grid={&#x27;n_neighbors&#x27;: [2, 3, 4, 5]}, return_train_score=True,\n",
       "             scoring=make_scorer(fbeta_score, beta=2), verbose=3)</pre></div></div></div><div class=\"sk-parallel\"><div class=\"sk-parallel-item\"><div class=\"sk-item\"><div class=\"sk-label-container\"><div class=\"sk-label sk-toggleable\"><input class=\"sk-toggleable__control sk-hidden--visually\" id=\"sk-estimator-id-2\" type=\"checkbox\" ><label for=\"sk-estimator-id-2\" class=\"sk-toggleable__label sk-toggleable__label-arrow\">estimator: KNeighborsClassifier</label><div class=\"sk-toggleable__content\"><pre>KNeighborsClassifier()</pre></div></div></div><div class=\"sk-serial\"><div class=\"sk-item\"><div class=\"sk-estimator sk-toggleable\"><input class=\"sk-toggleable__control sk-hidden--visually\" id=\"sk-estimator-id-3\" type=\"checkbox\" ><label for=\"sk-estimator-id-3\" class=\"sk-toggleable__label sk-toggleable__label-arrow\">KNeighborsClassifier</label><div class=\"sk-toggleable__content\"><pre>KNeighborsClassifier()</pre></div></div></div></div></div></div></div></div></div></div>"
      ],
      "text/plain": [
       "GridSearchCV(cv=2, estimator=KNeighborsClassifier(), n_jobs=12,\n",
       "             param_grid={'n_neighbors': [2, 3, 4, 5]}, return_train_score=True,\n",
       "             scoring=make_scorer(fbeta_score, beta=2), verbose=3)"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# knn estimator\n",
    "estimator = Estimator.knn_estimator\n",
    "model_evaluate(estimator, param_grids.get(estimator), **data_dict_oversampled)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Fitting 2 folds for each of 60 candidates, totalling 120 fits\n",
      "Estimator                  Accuracy         Recall      Precision       F1 score       F2 score \n",
      "\n",
      "forest_estimator             0.8528         0.4306         0.2726         0.3338         0.3859\n",
      "Best parameters for forest_estimator: \n",
      "class_weight: {0: 0.5468029990852277, 1: 5.841538040003653}\n",
      "max_features: sqrt\n",
      "max_samples: None\n",
      "min_samples_split: 10\n",
      "n_estimators: 1000\n",
      "n_jobs: -1\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1500x1500 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [
       "<style>#sk-container-id-2 {color: black;background-color: white;}#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>GridSearchCV(cv=2, estimator=RandomForestClassifier(random_state=42), n_jobs=12,\n",
       "             param_grid={&#x27;class_weight&#x27;: [{0: 1, 1: 1}, {0: 1, 1: 4},\n",
       "                                          {0: 0.5468029990852277,\n",
       "                                           1: 5.841538040003653}],\n",
       "                         &#x27;max_features&#x27;: [&#x27;sqrt&#x27;, &#x27;log2&#x27;],\n",
       "                         &#x27;max_samples&#x27;: [1000, None], &#x27;min_samples_split&#x27;: [10],\n",
       "                         &#x27;n_estimators&#x27;: [50, 100, 200, 800, 1000],\n",
       "                         &#x27;n_jobs&#x27;: [-1]},\n",
       "             return_train_score=True, scoring=make_scorer(fbeta_score, beta=2),\n",
       "             verbose=3)</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 sk-dashed-wrapped\"><div class=\"sk-label-container\"><div class=\"sk-label sk-toggleable\"><input class=\"sk-toggleable__control sk-hidden--visually\" id=\"sk-estimator-id-4\" type=\"checkbox\" ><label for=\"sk-estimator-id-4\" class=\"sk-toggleable__label sk-toggleable__label-arrow\">GridSearchCV</label><div class=\"sk-toggleable__content\"><pre>GridSearchCV(cv=2, estimator=RandomForestClassifier(random_state=42), n_jobs=12,\n",
       "             param_grid={&#x27;class_weight&#x27;: [{0: 1, 1: 1}, {0: 1, 1: 4},\n",
       "                                          {0: 0.5468029990852277,\n",
       "                                           1: 5.841538040003653}],\n",
       "                         &#x27;max_features&#x27;: [&#x27;sqrt&#x27;, &#x27;log2&#x27;],\n",
       "                         &#x27;max_samples&#x27;: [1000, None], &#x27;min_samples_split&#x27;: [10],\n",
       "                         &#x27;n_estimators&#x27;: [50, 100, 200, 800, 1000],\n",
       "                         &#x27;n_jobs&#x27;: [-1]},\n",
       "             return_train_score=True, scoring=make_scorer(fbeta_score, beta=2),\n",
       "             verbose=3)</pre></div></div></div><div class=\"sk-parallel\"><div class=\"sk-parallel-item\"><div class=\"sk-item\"><div class=\"sk-label-container\"><div class=\"sk-label sk-toggleable\"><input class=\"sk-toggleable__control sk-hidden--visually\" id=\"sk-estimator-id-5\" type=\"checkbox\" ><label for=\"sk-estimator-id-5\" class=\"sk-toggleable__label sk-toggleable__label-arrow\">estimator: RandomForestClassifier</label><div class=\"sk-toggleable__content\"><pre>RandomForestClassifier(random_state=42)</pre></div></div></div><div class=\"sk-serial\"><div class=\"sk-item\"><div class=\"sk-estimator sk-toggleable\"><input class=\"sk-toggleable__control sk-hidden--visually\" id=\"sk-estimator-id-6\" type=\"checkbox\" ><label for=\"sk-estimator-id-6\" class=\"sk-toggleable__label sk-toggleable__label-arrow\">RandomForestClassifier</label><div class=\"sk-toggleable__content\"><pre>RandomForestClassifier(random_state=42)</pre></div></div></div></div></div></div></div></div></div></div>"
      ],
      "text/plain": [
       "GridSearchCV(cv=2, estimator=RandomForestClassifier(random_state=42), n_jobs=12,\n",
       "             param_grid={'class_weight': [{0: 1, 1: 1}, {0: 1, 1: 4},\n",
       "                                          {0: 0.5468029990852277,\n",
       "                                           1: 5.841538040003653}],\n",
       "                         'max_features': ['sqrt', 'log2'],\n",
       "                         'max_samples': [1000, None], 'min_samples_split': [10],\n",
       "                         'n_estimators': [50, 100, 200, 800, 1000],\n",
       "                         'n_jobs': [-1]},\n",
       "             return_train_score=True, scoring=make_scorer(fbeta_score, beta=2),\n",
       "             verbose=3)"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# random forest estimator\n",
    "estimator = Estimator.forest_estimator\n",
    "model_evaluate(estimator, param_grids.get(estimator), **data_dict)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Fitting 2 folds for each of 12 candidates, totalling 24 fits\n",
      "Estimator                  Accuracy         Recall      Precision       F1 score       F2 score \n",
      "\n",
      "svc_estimator                0.7355          0.791         0.2154         0.3386         0.5155\n",
      "Best parameters for svc_estimator: \n",
      "class_weight: {0: 0.5468029990852277, 1: 5.841538040003653}\n",
      "kernel: poly\n"
     ]
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAlcAAAJiCAYAAADqjOeaAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjYuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8o6BhiAAAACXBIWXMAAA9hAAAPYQGoP6dpAACUKElEQVR4nOzdd3xTVR8G8CdJ23TvSSm0jJZdNrJXtbIEFZlCRV98VXAhKoiAvg5QFHGjKDIEWQKyRAEtG5G9W/bu3rtNzvvHbQOhLTQl6c14vp8PH5J7b25+vc14es655yqEEAJEREREZBRKuQsgIiIisiYMV0RERERGxHBFREREZEQMV0RERERGxHBFREREZEQMV0RERERGxHBFREREZEQMV0RERERGxHBFREREZEQMV1Sh0NBQPPXUU3KXYXN69OiBHj16yF3GPb3zzjtQKBRISUmRuxSzo1Ao8M477xhlX5cuXYJCocCCBQuMsj8A2L9/PxwcHHD58mWj7dPYhg0bhiFDhshdhtUwxeuI7o7hSgYLFiyAQqHQ/bOzs0NwcDCeeuopXL9+Xe7yzFpubi7ee+89tGjRAs7OzvDw8EDXrl2xaNEiWMqVnE6dOoV33nkHly5dkruUcjQaDX766Sf06NED3t7eUKvVCA0NxZgxY3DgwAG5yzOKpUuXYs6cOXKXoacma5oyZQqGDx+OunXr6pb16NFD7zPJyckJLVq0wJw5c6DVaivcT2pqKl5//XVERETA0dER3t7eiI6OxoYNGyp97qysLLz77ruIjIyEq6srnJyc0KxZM7z55pu4ceOGbrs333wTv/76K44ePWq8H9wGmONr+8aNG3jnnXdw5MgRuUupWYJq3E8//SQAiP/9739i8eLFYt68eeKZZ54RKpVK1K9fX+Tn58tdoigoKBBFRUVyl6EnISFBNG3aVCiVSjFixAjx3Xffic8//1x069ZNABBDhw4VJSUlcpd5TytXrhQAxN9//11uXWFhoSgsLKz5ooQQeXl54uGHHxYARLdu3cSsWbPEjz/+KKZOnSoiIiKEQqEQV69eFUIIMX36dAFAJCcny1Lr/ejXr5+oW7euyfafn58viouLDXpMZTVptVqRn59vtNf14cOHBQCxZ88eveXdu3cXtWvXFosXLxaLFy8Wn332mWjXrp0AIN56661y+zlz5owIDg4WDg4O4r///a+YN2+emDVrlmjZsqUAICZOnFjuMefPnxdhYWFCpVKJYcOGia+++kp8//33Yvz48cLHx0c0bNhQb/v27duLUaNGGeXnthU19ToyxL///isAiJ9++qnGn1tODFcyKAtX//77r97yN998UwAQy5cvl6kyeeXn5wuNRlPp+ujoaKFUKsVvv/1Wbt3EiRMFADFz5kxTllihnJwcg7a/W7iS07hx4wQA8dlnn5VbV1JSImbNmlWj4Uqr1Yq8vDyj79cU4Uqj0dzXH0WmDnxlXnrpJVGnTh2h1Wr1lnfv3l00bdpUb1l+fr6oW7eucHNz0/tSLioqEs2aNRPOzs5i3759eo8pKSkRQ4cOFQDEsmXLdMuLi4tFZGSkcHZ2Fjt37ixXV2ZmZrkQ98knnwgXFxeRnZ1d7Z/X1tTU68gQpgpXhn7u1jSGKxlUFq42bNggAIgPP/xQb/np06fF448/Lry8vIRarRZt2rSpMGCkp6eLV155RdStW1c4ODiI4OBgMWrUKL0vwIKCAjFt2jRRv3594eDgIGrXri1ef/11UVBQoLevunXripiYGCHErTfHggULyj3n5s2bBQCxfv163bJr166JMWPGCH9/f+Hg4CCaNGkifvzxR73H/f333wKA+OWXX8SUKVNErVq1hEKhEOnp6RUes7179woA4umnn65wfXFxsWjYsKHw8vLSfSFfvHhRABCzZs0Ss2fPFnXq1BGOjo6iW7du4vjx4+X2UZXjXPa7i42NFc8//7zw8/MTnp6eQgghLl26JJ5//nkRHh4uHB0dhbe3txg8eLC4ePFiucff+a8saHXv3l1079693HFavny5eP/990VwcLBQq9WiV69e4uzZs+V+hq+++kqEhYUJR0dH0a5dO7Fjx45y+6zI1atXhZ2dnXjwwQfvul2ZsnB19uxZERMTIzw8PIS7u7t46qmnRG5urt628+fPFz179hR+fn7CwcFBNG7cWHzzzTfl9lm3bl3Rr18/sXnzZtGmTRuhVqt1Qa+q+xBCiE2bNolu3boJV1dX4ebmJtq2bSuWLFkihJCO753H/vYvo6q+PwCIcePGiZ9//lk0adJE2NnZiTVr1ujWTZ8+XbdtVlaWePnll3XvSz8/PxEVFSUOHjx4z5rKXsN3fjGdPn1aPPHEE8LX11c4OjqK8PDwCluY7lSnTh3x1FNPlVteUbgSQojBgwcLAOLGjRu6Zb/88ouu5b0iGRkZwtPTUzRq1Ei3bNmyZQKA+OCDD+5ZY5mjR48KAGL16tVVfkxV/Pvvv+Khhx4SPj4+wtHRUYSGhooxY8YIIaTg6OXlVeExyszMFGq1Wrz22mu6Zfn5+WL69OmiYcOGQq1Wi8DAQPHoo4+Kc+fOGVTTvn37RHR0tHB3dxdOTk6iW7duYteuXXrbGPt1FBMTI1xcXMTly5dFv379hIuLi6hVq5b46quvhBBCHDt2TPTs2VM4OzuLOnXq6N5DZVJTU8Vrr70mmjVrJlxcXISbm5t4+OGHxZEjR3TblH1+3fnv9jpWrFghWrduLRwdHYWPj48YOXKkuHbtmt5zldV67tw50adPH+Hq6ioGDhxo0DGuaXZG61+k+1Y2BsfLy0u37OTJk+jcuTOCg4MxadIkuLi4YMWKFRg0aBB+/fVXPProowCAnJwcdO3aFadPn8bTTz+N1q1bIyUlBevWrcO1a9fg6+sLrVaLRx55BLt27cKzzz6Lxo0b4/jx4/jss88QHx+PtWvXVlhX27ZtUa9ePaxYsQIxMTF665YvXw4vLy9ER0cDABITE/HAAw9AoVBg/Pjx8PPzw++//45nnnkGWVlZeOWVV/Qe/95778HBwQETJ05EYWEhHBwcKqxh/fr1AIDRo0dXuN7Ozg4jRozAu+++i927dyMqKkq3btGiRcjOzsa4ceNQUFCAzz//HL169cLx48cREBBg0HEu88ILL8DPzw/Tpk1Dbm4uAODff//Fnj17MGzYMNSuXRuXLl3Ct99+ix49euDUqVNwdnZGt27d8NJLL+GLL77AW2+9hcaNGwOA7v/KzJw5E0qlEhMnTkRmZiY+/vhjjBw5Ev/8849um2+//Rbjx49H165d8eqrr+LSpUsYNGgQvLy8ULt27bvu//fff0dJSQlGjRp11+3uNGTIEISFhWHGjBk4dOgQfvjhB/j7++Ojjz7Sq6tp06Z45JFHYGdnh/Xr1+OFF16AVqvFuHHj9PYXFxeH4cOH47///S/Gjh2LiIgIg/axYMECPP3002jatCkmT54MT09PHD58GJs3b8aIESMwZcoUZGZm4tq1a/jss88AAK6urgBg8Pvjr7/+wooVKzB+/Hj4+voiNDS0wmP03HPPYdWqVRg/fjyaNGmC1NRU7Nq1C6dPn0br1q3vWlNFjh07hq5du8Le3h7PPvssQkNDcf78eaxfvx4ffPBBpY+7fv06rly5gtatW1e6zZ3KBkJ7enrqlt3rvejh4YGBAwdi4cKFOHfuHBo0aIB169YBgEGvryZNmsDJyQm7d+8u9/6rrqSkJDz00EPw8/PDpEmT4OnpiUuXLmH16tUAAHt7ezz66KNYvXo1vvvuO73Po7Vr16KwsBDDhg0DII1P7N+/P7Zt24Zhw4bh5ZdfRnZ2NrZs2YITJ06gfv36Varpr7/+Qp8+fdCmTRtMnz4dSqUSP/30E3r16oWdO3eiffv2AIz/Oir7Gfr06YNu3brh448/xpIlSzB+/Hi4uLhgypQpGDlyJB577DHMnTsXo0ePRseOHREWFgYAuHDhAtauXYsnnngCYWFhSExMxHfffYfu3bvj1KlTqFWrFho3boz//e9/mDZtGp599ll07doVANCpUycA0vt1zJgxaNeuHWbMmIHExER8/vnn2L17Nw4fPqz3uispKUF0dDS6dOmCTz75BM7OzlU6vrKRO93ZorLWi61bt4rk5GRx9epVsWrVKuHn5yfUarWu60UIIXr37i2aN2+u95ezVqsVnTp10hujMG3atEr/yivrAli8eLFQKpXlmuXnzp0rAIjdu3frlt3eciWEEJMnTxb29vYiLS1Nt6ywsFB4enrqtSY988wzIigoSKSkpOg9x7Bhw4SHh4euVansL5p69epVqetn0KBBAkClLVtCCLF69WoBQHzxxRdCiFt/rTk5Oen9JfTPP/8IAOLVV1/VLavqcS773XXp0qXc+IWKfo6yFrdFixbplt2tW7CylqvGjRvrjcX6/PPPBQBdC1xhYaHw8fER7dq10xvvs2DBAgHgni1Xr776qgAgDh8+fNftypS1XN3Zkvjoo48KHx8fvWUVHZfo6GhRr149vWV169YVAMTmzZvLbV+VfWRkZAg3NzfRoUOHcl10t3eDVdZ1Ysj7A4BQKpXi5MmT5faDO1quPDw8xLhx48ptd7vKaqqoxaFbt27Czc1NXL58udKfsSJbt24t18pcpnv37qJRo0YiOTlZJCcnizNnzojXX39dABD9+vXT27Zly5bCw8Pjrs81e/ZsAUCsW7dOCCFEq1at7vmYioSHh4s+ffoY/LjKrFmzpsJeg9v98ccfFR6nvn376r3e5s+fLwCI2bNnl9vHvX4Xt2/XsGFDER0drfeYvLw8ERYWpteSbOzXUUxMTLmekvT0dOHk5CQUCoVet+6ZM2fKva4LCgrKDeO4ePGiUKvVeq2alXULFhUVCX9/f9GsWTO992tZD860adPK1Tpp0qS7/vzmhGcLyigqKgp+fn4ICQnB4MGD4eLignXr1ulaGdLS0vDXX39hyJAhyM7ORkpKClJSUpCamoro6GicPXtWd3bhr7/+isjIyAr/wlMoFACAlStXonHjxmjUqJFuXykpKejVqxcA4O+//6601qFDh6K4uFj3Fx4A/Pnnn8jIyMDQoUMBAEII/PrrrxgwYACEEHrPER0djczMTBw6dEhvvzExMXBycrrnscrOzgYAuLm5VbpN2bqsrCy95YMGDUJwcLDufvv27dGhQwds2rQJgGHHuczYsWOhUqn0lt3+cxQXFyM1NRUNGjSAp6dnuZ/bUGPGjNH7K7rsL8ALFy4AAA4cOIDU1FSMHTsWdna3GqRHjhyp1xJambJjdrfjW5HnnntO737Xrl2Rmpqq9zu4/bhkZmYiJSUF3bt3x4ULF5CZman3+LCwMF0r6O2qso8tW7YgOzsbkyZNgqOjo97jy94Dd2Po+6N79+5o0qTJPffr6emJf/75R+9suOpKTk7Gjh078PTTT6NOnTp66+71M6ampgJApa+HM2fOwM/PD35+fmjUqBFmzZqFRx55pNzp+9nZ2fd8ndz5XszKyjL4tVVWqzGn+yhrCdmwYQOKi4sr3KZXr17w9fXF8uXLdcvS09OxZcsW3WcdIH3m+vr64sUXXyy3j6q83gDgyJEjOHv2LEaMGIHU1FTday43Nxe9e/fGjh07dGdrGvN1dLv//Oc/utuenp6IiIiAi4uL3lQYERER8PT01H3eAIBarYZSKUUIjUaD1NRUuLq6IiIiokqfdwcOHEBSUhJeeOEFvfdrv3790KhRI2zcuLHcY55//vlq/YxyYLegjL7++muEh4cjMzMT8+fPx44dO6BWq3Xrz507ByEEpk6diqlTp1a4j6SkJAQHB+P8+fN4/PHH7/p8Z8+exenTp+Hn51fpvioTGRmJRo0aYfny5XjmmWcASF2Cvr6+ui+f5ORkZGRk4Pvvv8f3339fpecoa2K+l7IP5uzsbL2m4ttVFsAaNmxYbtvw8HCsWLECgGHH+W515+fnY8aMGfjpp59w/fp1vakh7gwRhrrzi7TsCzI9PR0AdHMWNWjQQG87Ozu7Srurbufu7g7g1jE0Rl1l+9y9ezemT5+OvXv3Ii8vT2/7zMxMeHh46O5X9nqoyj7Onz8PAGjWrJlBP0MZQ98fVX3tfvzxx4iJiUFISAjatGmDvn37YvTo0ahXr57BNZZ9uVX3ZwRQ6ZQloaGhmDdvHrRaLc6fP48PPvgAycnJ5YKqm5vbPQPPne9Fd3d3vS9mQ2q9V1BJS0tDUVGR7r6Tk5Pea+p23bt3x+OPP453330Xn332GXr06IFBgwZhxIgRus9eOzs7PP7441i6dCkKCwuhVquxevVqFBcX64Wr8+fPIyIiQu+PGUOdPXsWAMoNt7hdZmYmvLy8jPo6KuPo6Fju9e7h4YHatWuXO+4eHh66zxtA6kb//PPP8c033+DixYvQaDS6dT4+Pvd87rLPrLKu/9s1atQIu3bt0ltmZ2d3z+EN5oThSkbt27dH27ZtAUitK126dMGIESMQFxcHV1dX3V8sEydOrPCveaD8l+ndaLVaNG/eHLNnz65wfUhIyF0fP3ToUHzwwQdISUmBm5sb1q1bh+HDh+s+XMrqffLJJyv9sGjRooXe/aq0WgHSmKS1a9fi2LFj6NatW4XbHDt2DACq1Jpwu+oc54rqfvHFF/HTTz/hlVdeQceOHeHh4QGFQoFhw4ZVOldQVd3ZSlamsi9KQzVq1AgAcPz4cbRs2bLKj7tXXefPn0fv3r3RqFEjzJ49GyEhIXBwcMCmTZvw2WeflTsuFR1XQ/dRXYa+P6r62h0yZAi6du2KNWvW4M8//8SsWbPw0UcfYfXq1ejTp899111VZV94t39B3s7FxUVvrGLnzp3RunVrvPXWW/jiiy90yxs3bowjR47gypUr5cJ1mTvfi40aNcLhw4dx9erVe37O3C49Pb3CP45u99hjj2H79u26+zExMZVOlqlQKLBq1Srs27cP69evxx9//IGnn34an376Kfbt26cbozRs2DB89913+P333zFo0CCsWLECjRo1QmRkZJVrr4qy1+6sWbMqfd+V1WSK11Fl79+qfN58+OGHmDp1Kp5++mm899578Pb2hlKpxCuvvGK09+Ttbm8pswQMV2ZCpVJhxowZ6NmzJ7766itMmjRJ9xeJvb293odeRerXr48TJ07cc5ujR4+id+/eVW62vt3QoUPx7rvv4tdff0VAQACysrJ0gzsBwM/PD25ubtBoNPes11D9+/fHjBkzsGjRogrDlUajwdKlS+Hl5YXOnTvrrSv76/B28fHxuhYdQ47z3axatQoxMTH49NNPdcsKCgqQkZGht111jv29lE0Iee7cOfTs2VO3vKSkBJcuXSoXau/Up08fqFQq/PzzzwYPar+b9evXo7CwEOvWrdP7Ir5bF3R191E2gPjEiRN3/aOjsuN/v++PuwkKCsILL7yAF154AUlJSWjdujU++OAD3ZdiVZ+v7LV6r/d6RcoC9MWLF6u0fYsWLfDkk0/iu+++w8SJE3XHvn///vjll1+waNEivP322+Uel5WVhd9++w2NGjXS/R4GDBiAX375BT///DMmT55cpecvKSnB1atX8cgjj9x1u08//VQvMNaqVeue+37ggQfwwAMP4IMPPsDSpUsxcuRILFu2TNdF1q1bNwQFBWH58uXo0qUL/vrrL0yZMkVvH/Xr18c///yD4uJi2NvbV+lnulPZa9bd3b1Knz3Geh0Zw6pVq9CzZ0/8+OOPesszMjLg6+uru19ZTWWfWXFxcbrejzJxcXF6k9xaIsuJgTagR48eaN++PebMmYOCggL4+/ujR48e+O6773Dz5s1y2ycnJ+tuP/744zh69CjWrFlTbruyvzaGDBmC69evY968eeW2yc/P1531VpnGjRujefPmWL58OZYvX46goCC9oKNSqfD444/j119/rfDD//Z6DdWpUydERUXhp59+qnAG6ClTpiA+Ph5vvPFGuRaFtWvX6o2Z2r9/P/755x/dB5Ihx/luVCpVuZakL7/8Uq+5HJBaCACUC133o23btvDx8cG8efNQUlKiW75kyZJKWypuFxISgrFjx+LPP//El19+WW69VqvFp59+imvXrhlUV9lfwHd2kf70009G38dDDz0ENzc3zJgxAwUFBXrrbn+si4tLhd209/v+qIhGoyn3XP7+/qhVqxYKCwvvWdOd/Pz80K1bN8yfPx9XrlzRW3evVszg4GCEhIQYNNP+G2+8geLiYr3WvMGDB6NJkyaYOXNmuX1ptVo8//zzSE9Px/Tp0/Ue07x5c3zwwQfYu3dvuefJzs4uF15OnTqFgoIC3ZlllWnTpg2ioqJ0/+7Wcp2enl7uOJW1GN3++1AqlRg8eDDWr1+PxYsXo6SkRK9LEJA+c1NSUvDVV1+Ve56qtii3adMG9evXxyeffIKcnJxy68s+e4z9OjKGij7vVq5cWW58amWfd23btoW/vz/mzp2r9zP8/vvvOH36NPr162eawmsIW67MzOuvv44nnngCCxYswHPPPYevv/4aXbp0QfPmzTF27FjUq1cPiYmJ2Lt3L65du6a7PMTrr7+OVatW4YknnsDTTz+NNm3aIC0tDevWrcPcuXMRGRmJUaNGYcWKFXjuuefw999/o3PnztBoNDhz5gxWrFiBP/74Q9dNWZmhQ4di2rRpcHR0xDPPPFOumXbmzJn4+++/0aFDB4wdOxZNmjRBWloaDh06hK1btyItLa3ax2bRokXo3bs3Bg4ciBEjRqBr164oLCzE6tWrERsbi6FDh+L1118v97gGDRqgS5cueP7551FYWIg5c+bAx8cHb7zxhm6bqh7nu+nfvz8WL14MDw8PNGnSBHv37sXWrVvLjT9o2bIlVCoVPvroI2RmZkKtVqNXr17w9/ev9rFxcHDAO++8gxdffBG9evXCkCFDcOnSJSxYsAD169ev0l+0n376Kc6fP4+XXnoJq1evRv/+/eHl5YUrV65g5cqVOHPmjF5LZVU89NBDcHBwwIABA/Df//4XOTk5mDdvHvz9/SsMsvezD3d3d3z22Wf4z3/+g3bt2mHEiBHw8vLC0aNHkZeXh4ULFwKQvtCWL1+OCRMmoF27dnB1dcWAAQOM8v64U3Z2NmrXro3BgwfrLvmydetW/Pvvv3otnJXVVJEvvvgCXbp0QevWrfHss88iLCwMly5dwsaNG+95iZGBAwdizZo1VRrLBEjden379sUPP/yAqVOnwsfHBw4ODli1ahV69+6NLl26YMyYMWjbti0yMjKwdOlSHDp0CK+99prea8Xe3h6rV69GVFQUunXrhiFDhqBz586wt7fHyZMnda3Ot08lsWXLFjg7O+PBBx+8Z51VtXDhQnzzzTd49NFHUb9+fWRnZ2PevHlwd3dH37599bYdOnQovvzyS0yfPh3NmzcvN13K6NGjsWjRIkyYMAH79+9H165dkZubi61bt+KFF17AwIED71mPUqnEDz/8gD59+qBp06YYM2YMgoODcf36dfz9999wd3fH+vXrTfI6ul/9+/fH//73P4wZMwadOnXC8ePHsWTJknJjwOrXrw9PT0/MnTsXbm5ucHFxQYcOHRAWFoaPPvoIY8aMQffu3TF8+HDdVAyhoaF49dVXTVJ3janZkxNJiMonERVCmum5fv36on79+rpT/c+fPy9Gjx4tAgMDhb29vQgODhb9+/cXq1at0ntsamqqGD9+vO6yFLVr1xYxMTF60yIUFRWJjz76SDRt2lSo1Wrh5eUl2rRpI959912RmZmp2+7OqRjKnD17VjcR3J2T3JVJTEwU48aNEyEhIcLe3l4EBgaK3r17i++//163TdkUAytXrjTo2GVnZ4t33nlHNG3aVDg5OQk3NzfRuXNnsWDBgnKnP98+ieinn34qQkJChFqtFl27dhVHjx4tt++qHOe7/e7S09PFmDFjhK+vr3B1dRXR0dHizJkzFR7LefPmiXr16gmVSlWlSUTvPE6VTS75xRdfiLp16wq1Wi3at28vdu/eLdq0aSMefvjhKhxdaYbtH374QXTt2lV4eHgIe3t7UbduXTFmzBi9aRoqm6G97PjcPnHqunXrRIsWLXQTNn700Ue609hv365sEtGKVHUfZdt26tRJODk5CXd3d9G+fXvxyy+/6Nbn5OSIESNGCE9Pz3KTiFb1/YHSSUQrgttOWS8sLBSvv/66iIyMFG5ubsLFxUVERkaWmwC1spoq+z2fOHFCPProo8LT01M4OjqKiIgIMXXq1Arrud2hQ4cEgHLTTVQ2iagQQsTGxpY7DV8IIZKSksSECRNEgwYNhFqtFp6eniIqKko3/UJF0tPTxbRp00Tz5s2Fs7OzcHR0FM2aNROTJ08WN2/e1Nu2Q4cO4sknn7znz2SIQ4cOieHDh4s6deoItVot/P39Rf/+/cWBAwfKbavVakVISIgAIN5///0K95eXlyemTJkiwsLCdJ91gwcPFufPnzeorsOHD4vHHntM+Pj4CLVaLerWrSuGDBkitm3bJoQwzeuobGLOO1X2Wrjz/VlQUCBee+01ERQUJJycnETnzp3F3r17K5y0+LffftNNtntnHcuXLxetWrUSarVaeHt733USUUuiEMJCrnZLZKBLly4hLCwMs2bNwsSJE+UuRxZarRZ+fn547LHHKuzuItvTu3dv1KpVC4sXL5a7lEodOXIErVu3xqFDhww6wYLIXHDMFZGVKCgoKDcGYtGiRUhLS0OPHj3kKYrMzocffojly5frToU3RzNnzsTgwYMZrMhiccwVkZXYt28fXn31VTzxxBPw8fHBoUOH8OOPP6JZs2Z44okn5C6PzESHDh305oUyR8uWLZO7hPt25/xbd1KpVJXOqUaWj+GKyEqEhoYiJCQEX3zxBdLS0uDt7Y3Ro0dj5syZlV6zkYhM4875t+5Ut25d3fVkyfpwzBUREZGRHTx48K7ToDg5OZWbk4+sB8MVERERkRFxQDsRERGREdncmCutVosbN27Azc2tRi8VQERERJZNCIHs7GzUqlXrrtc6tLlwdePGDYMuHEpERER0u6tXr6J27dqVrre5cOXm5gZAOjDu7u4yV0NERESWIisrCyEhIbosURmbC1dlXYHu7u4MV0RERGSwew0r4oB2IiIiIiNiuCIiIiIyIoYrIiIiIiNiuCIiIiIyIoYrIiIiIiNiuCIiIiIyIoYrIiIiIiNiuCIiIiIyIoYrIiIiIiNiuCIiIiIyIoYrIiIiIiNiuCIiIiIyIoYrIiIiIiNiuCIiIiIyIoYrIiIiIiNiuCIiIiIyIoYrIiIiIiOSNVzt2LEDAwYMQK1ataBQKLB27dp7PiY2NhatW7eGWq1GgwYNsGDBApPXSURERFRVsoar3NxcREZG4uuvv67S9hcvXkS/fv3Qs2dPHDlyBK+88gr+85//4I8//jBxpURERERVYyfnk/fp0wd9+vSp8vZz585FWFgYPv30UwBA48aNsWvXLnz22WeIjo42VZlVptVqUVRUBABQqVRQKBQyV0RERGT9hBA4n5COXeczEezthIebB8v6HSxruDLU3r17ERUVpbcsOjoar7zySqWPKSwsRGFhoe5+VlaWqcpDUVERtm7darL9ExERUeUCAWhyAE2TQNjZyRdxLGpAe0JCAgICAvSWBQQEICsrC/n5+RU+ZsaMGfDw8ND9CwkJqYlSiYiIyEZZVMtVdUyePBkTJkzQ3c/KyjJZwFKpVLrbUVFRsqZmIiIiS5ddWIy951Kx82wKdp1NQWJ2gd76ut7OGOdzEP2vzoKwc4RiyCIgtIve97EcLOrbPzAwEImJiXrLEhMT4e7uDicnpwofo1aroVara6I8vf5dOzs7hisiIiIDCCFw6mYWYuOSsT0uGQevpEOjFbr1jvYqdKzngx4R/uge7odQXxdA9AT+LgRCuwL1ustY/S0W9e3fsWNHbNq0SW/Zli1b0LFjR5kqIiIiovuRmVeMneekMLU9PhlJ2YV66+v5uaBHuD96RPihfZg3HO1VQPFtQ4EUCqDX2zVc9d3JGq5ycnJw7tw53f2LFy/iyJEj8Pb2Rp06dTB58mRcv34dixYtAgA899xz+Oqrr/DGG2/g6aefxl9//YUVK1Zg48aNcv0IREREZACtVuDkjSxsj09CbFwyDl/N0GudcrJXoXMDH3QP90OPCH+EeDvr76A4H/hluBSqhv0C2DvW8E9wb7KGqwMHDqBnz566+2Vjo2JiYrBgwQLcvHkTV65c0a0PCwvDxo0b8eqrr+Lzzz9H7dq18cMPP5jFNAxERERUsYy8Iuw4m4LYuCTsiE9BSo5+61RDf1ddmGoX5gW1XSVjporygGXDgQuxgL0LkBIHBEWa/gcwkKzhqkePHhBCVLq+otnXe/TogcOHD5uwKiIiIrofWq3A8euZiI1LRmx8Eo5ezcBtjVNwcVChUwNf9IjwQ/dwP9T2cq58Z2WK8oBfhgEXt0vB6slVZhmsAAsbc0VERETmKS23CDvik6XWqbMpSMst0lsfEeAmhakIP7St6w0HOwNmgyrKBZYOBS7tBBxcgZGrgLrmO96a4YqIiIgMptEKHL2WIZ3ZF5+MY9cycHtnlKvaDl1KW6e6hfuhlmfFZ/Xfk16wcgOe/BWo08E4P4SJMFwRERFRlSRnF2Ln2WTExiVj59lkpOcV661vHOSu6+prU9cL9iojzFWedhG4eVQKVqNWAyHt73+fJsZwRURERBUq0Wh1rVOxcck4fj1Tb72box26NvRFj3B/dI/wQ4C7Cc7cC2wGjFoDCK1FBCuA4YqIiIhuk5RdgO1xyYiNT8ausynIzNdvnWpaS2qd6hHhj1YhnrAzRuvUnQqzgfTLUrACgNptjf8cJsRwRUREZMNKNFocupKB2Dhp3qlTN7P01ns42UutUxH+6BbuC383E88rVZgN/DwYSDoNjF4LBLc27fOZAMMVERGRjUnILMD2+CRsj0/GzrMpyC4o0VvforYHeoT7oXuEPyJre5imdaoiBVnAksHA1X8AtQeAyqdrMmcMV0RERFauWKPFgUvp2F46VcKZhGy99V7O9ugW7oceEX7o2tAPvq41c01ePQVZwM+PA9f2A44ewKi1FtlqBTBcERERWaUbGfm6MLX7XCpyCm+1TikUQGRtz9JZ0f3QorYnVEqFfMUWZJYGq38BR0+pO7BWK/nquU8MV0RERFagqESLA5fSEFsaqOITc/TW+7g46LVOebs4yFTpHQoygcWPAdcPlAar34BaLeWu6r4wXBEREVmoa+l5umkS9pxPQV6RRrdOqQBahniiR4Q/ekT4oVktDyjlbJ2qjNIecHABnLykYGWml7QxBMMVERGRhSgs0WD/xTTdrOjnkvRbp3xd1bquvq4NfeHpbCatU3fj4AwMXwZkXgX8IuSuxigYroiIiMzYldQ8xMYnYXtcMvacT0V+8a3WKZVSgdZ1pNap7uF+aBLkbp6tU3fKTweOrwLa/UcaAObgbDXBCmC4IiIiMisFxRr8czENsXFSoLqQkqu33t9NXXqJGX90aegLDyd7mSqtpvx0YNEg4OYRoDAL6Pqa3BUZHcMVERGRzC6l5EqTeMYnY9+FVBQUa3Xr7JQKtK7rJc2KHu6PxkFuUCgsoHWqInlpwOJB0rUCnX2B8D5yV2QSDFdEREQ1LL9Ig30XUnWB6nJqnt76QHfH0kvM+KFTA1+4O1pY61RF8tKARY8ACcelYBWzHghoIndVJsFwRUREZGJCCFxIydUNRN93IRVFJbdap+xVCrSt6627Zl94gKvltk5V5PZg5eInBSv/xnJXZTIMV0RERCaQV1SCPedSpYk845NwNS1fb32wpxO6R/ihR7jUOuWqttKvZE0xsGhgabDyLw1WjeSuyqSs9DdJRERUs4QQOJeUUzorejL2X0xDkeZW65SDSon2Yd66qRIa+FtZ61RlVPbSWYF/fwjErLOqswIrw3BFRERUTTmFJdhzLgWx8cnYHpeM6xn6rVO1vZx0A9E71veBi7W2Tt1Lmxig2WOA2k3uSmqEjf6WiYiIDCeEQHxijjQQPS4ZBy6noVgjdOsd7JToEOatmxW9nq+LbbRO3SknGfj9daDvJ4CLr7TMRoIVwHBFRER0V9kFxdh9LkU3GP1mZoHe+ro+zugRLg1Ef6CeD5wcVDJVaiZykoCFA4DkM0BBFjBqtdwV1TiGKyIiotsIIXD6ZrZuVvSDl9NRor3VOqW2U6JjfR/0CPdD9wh/hPm6yFitmbk9WLnVAvrOkrsiWTBcERGRzcvML2udSsL2+GQkZhXqra/n64LuEX7oHu6HB+r5wNHexlunKpKdKAWrlDjAPVg6K9CnvtxVyYLhioiIbI5WK3DqZlbpmX1JOHQlA5rbWqec7FXoVN+ndKoEf9TxcZaxWguQnVAarOKlYPXUBsC7ntxVyYbhioiIbEJGXhF2nr01diolR791qr6fi24gertQb7ZOGWLtC6XBqjbw1HqbDlYAwxUREVkprVbgxI1MXZg6fCUdtzVOwdlBhU71fUsvguyHEG+2TlVb/8+Atc8DA78GvMPkrkZ2DFdERGQ10nKLsPOsNOfUjrPJSMkp0lsfHuAqtU6F+6FNqBfUdmydqjZNCaAqjRFedYGnNgK2OO1EBRiuiIjIYmm0AseuZehmRT96LQPittYpV7UdOjfwQfdwf3SP8EOwp5N8xVqTzOvA4keB3tOAxv2lZQxWOgxXRERkUVJyCrHzrBSmdsQnIz2vWG99o0A33UD0NnW94GCnlKlSK5V5DVjQH0i/CGydDoRHS5e4IR2GKyIiMmsarcCRqxnYHpeE2PhkHL+eqdc65aa2Q5eGZWOn/BHo4ShfsdYu4yqwsD+QfgnwrAuMWsNgVQGGKyIiMjvJ2YW6aRJ2nk1BZr5+61STIHfpmn0R/mhVxxP2KrZOmVzGVWBBPyDjMuAVCsRsADxD5K7KLDFcERGR7Eo0Why+mqGbxPPE9Sy99e6Oduga7ifNih7uB393tk7VqIwrUldgWbB6aiPgUVvuqswWwxUREckiMasA2+OlM/t2nk1GVkGJ3vrmwR66aRJahnjCjq1T8jm0qDRYhZUGq2C5KzJrDFdERFQjijVaHLycrjuz7/RN/dYpT2d7dG0otU51C/eDn5tapkqpnB5vAVAAbccA7rXkrsbsMVwREZHJ3MzMx/Y4KUztPpeC7MJbrVMKBdAi2APdS2dFj6ztCZWSp/ObjaybgIuvNGBdqQR6TZG7IovBcEVEREZTVKLFgctpukAVl5itt97bxQHdGvqiR4Q/ujb0hY8rW6fMUtpF6VqBtdsCj/1wa7JQqhIeLSIiui/XM/IRG5eE2Lhk7DmXgtwijW6dQgG0DPFEj9JJPJsHe7B1ytylXQAWDACyrgF2jkBBhtSCRVXGcEVERAYpLNHg34vp2B4vBaqzSTl6631dHdCt9Ky+bg394OXiIFOlZLDU81KLVdZ1wDdcmm6BwcpgDFdERHRPV9PyEBufjO1xSdhzPhV5t7VOKRVA6zpe6B4uzTvVtJY7lGydsjyp56XpFrJvAL4RQMx6wC1A7qosEsMVERGVU1Cswf6LaYiNS0ZsfBIuJOfqrfdzU5eGKT90beAHD2fO0m3RUs9LE4Rm3wT8GknBytVf7qosFsMVEREBAC6n5kphKi4Jey+koqBYq1unUirQpo6XdM2+CD80CXKHghfqtR5Z14H8dMCvMRCzjsHqPjFcERHZqIJiDfZeSC09sy8Jl1Lz9NYHuKvRI1yaJqFTA194OLF1ymqFdQOeXC2Ns3L1k7sai8dwRURkI4QQuJgitU5tj0/GvgupKCy51Tplp1SgbagXekT4o3u4HxoFurF1ypolxwMQgF+EdD+0s6zlWBOGKyIiK5ZXVIJ9F1JLu/uScSVNv3UqyMOx9BIz/ujcwAdujmydsgnJcdLgdQAY8zvg20DeeqwMwxURkRURQuB8cq7uAsj/XExD0W2tU/YqBdqFeqNHhHRmX0N/V7ZO2ZqkM8DC/kBuMhDQHHD2lrsiq8NwRURk4XILS7DnfKouUF1Lz9dbH+zppAtTner7wEXNj36blXRaarHKSwECmwOj1zFcmQDfYUREFkYIgbNJObpZ0f+9lIZijdCtd1Ap0aGet27eqfp+LmydIiDxlDRBaF4KENgCGP0bg5WJMFwREVmA7IJi7D6Xiu2lE3neyCzQW1/H27l07JQfOtb3gbMDP97pNslxUldgXioQFAmMWstgZUJ89xERmSEhBM4kZGN7vDRNwoFL6SjR3mqdUtsp8UA9H91EnmG+bJ2iu3ANADzrAh4hwOi1gJOX3BVZNYYrIiIzkVVQjN1nU3RTJSRk6bdOhfm6oHu4H7pH+OGBMB84OahkqpQsjpMnMGoNAMFgVQMYroiIZCKEwKmbWVKYikvGwSvp0NzWOuVor0THej7oESFN5FnXx0XGasni3DwGXNkHdHhWuu/kKWs5toThioioBmXmFWPnuWRd61RydqHe+np+LrpZ0duHecPRnq1TVA03jwILHwEKMqRQ1WKI3BXZFIYrIiIT0moFTt7I0k2TcOhKOm5rnIKTvQqdG/ige4Q/eoT7IcTbWb5iyTrcOAIsGigFq9rtgPBouSuyOQxXRERGlp5bhB1npZapHfHJSMkp0lvf0N9VN01CuzAvqO3YOkVGcuNwabDKBGq3B578FXB0l7sqm8NwRUR0n7RagePXM6VLzMQn4ejVDL3WKRcHFTo18NVNlVDbi61TZALXDwGLB0nBKqQDMHIVg5VMGK6IiKohNacQO8+mIDYuCTvOpiAtV791KiLATQpTEX5oW9cbDnZKmSolm5CTBCwaBBRmAiEPAE+uAtRucldlsxiuiIiqQKMVOHoto/TMviQcu54JcVvrlJvaDp3LWqci/BDk4SRfsWR7XP2BrhOA+D+AkSsYrGTGcEVEVInk7ELsiE9GbHwydp5NRkZesd76xkHu0jX7wv3Quq4X7FVsnSIZdXkF6DgOUNnLXYnNY7giIipVotHiyNWM0lnRk3H8eqbeejdHO3Rr6KebyDPA3VGmSokAXN0PxM4Enlhwa2wVg5VZYLgiIpuWlFUghan4ZOw6m4LMfP3Wqaa1SlunIvzRKsQTdmydInNw5R/g58eBomwgdgbw8Ay5K6LbMFwRkU0p0Whx6EoGYuOSEBuXjFM3s/TWezjZo2tDX/SI8Ee3cF/4u7F1iszMlX2lwSoHCO0K9Hpb7oroDgxXRGT1EjILsD1eClO7zqUgu6BEb32L2h7oEe6H7hH+iKztwdYpMl+X9wJLBkvBKqwbMHw54MCpPcwNwxURWZ1ijRYHLqUjNj4J2+OScSYhW2+9l7M9uoX7oUeEH7o29IOvq1qmSokMcHkP8PNgoDgXCOsODF/GYGWmGK6IyCrcyMgvvV5fEnafS0VO4a3WKYUCiKztqZvEs0VtT6iUChmrJTKQphhY+7wUrOr1AIb9wmBlxhiuiMgiFZZocOBSeumZfUmIT8zRW+/j4qDXOuXt4iBTpURGoLKXWqp2fgo88iVgz3nUzBnDFRFZjGvpedIlZuKSsed8CvKKNLp1SgXQMsQTPSL80SPCD81qeUDJ1imydIU5gNpVuu3fGHj8B3nroSphuCIis1VYosH+i2mlgSoJ55Nz9db7uqpLL4Dsh64NfeHpzNYpsiIXtgOrxgCDfwLqdZe7GjIAwxURmZUrqXmILT2zb+/5VOQX32qdUikVaF1Hap3qHu6HJkHubJ0i63QhFlg6DCjJB/79geHKwjBcEZGsCoo12HchFbFxydgRn4wLKfqtU/5u6tKB6P7o0tAXHk6cgZqs3Pm/gV+GASUFQMOH2BVogRiuiKjGXUzJxfa4JMTGJ2PfhVQUFGt16+yUCrSu61V6zT5/NA5yg0LB1imyEef/An4ZXhqsooGhiwE7ThViaRiuiMjk8ovKWqekQHU5NU9vfaC7Y+klZvzQqYEv3B3ZOkU26Nw2YNkIKViF9wGGLGSwslAMV0RkdEIIXEjJ1Q1E/+diGopKbrVO2asUaFvXW3fNvvAAV7ZOER1dJgWriL7AEwsBO56gYakYrojIKPKKSrDnXKo0K3p8Mq6m5eutD/Z0QvcIP/QIl1qnXNX8+CHSM+gbIKgF0P6/DFYWjp9uRFQtQgicS8qRWqfik/DvxXQUaW61TjmolGgf5q2bKqGBP1uniMpJOA74NwWUSmmi0E4vyl0RGQHDFRFVWU5hCXafS8H2+GRsj0vG9Qz91qnaXk66gegd6/vAha1TRJWL2wysGAW0HAn0my0FLLIK/OQjokoJIRCfmCMNRI9LxoHLaSjWCN16BzslOoR562ZFr+frwtYpoqqI+x1YPgrQFgP5aYDQAmC4shYMV0SkJ7ugGLvPpZReBDkZNzML9NbX9XFGj3BpIPoD9Xzg5KCSqVIiC3VmE7BitBSsmj4KPDYPUPHr2Jrwt0lk44QQOH0zWzcr+qHL6SjR3mqdUtsp0bG+D3qE+6F7hD/CfF1krJbIwp3ZCKyIKQ1WjzFYWSn+RolsUGZ+MXadTUFsnHRmX1J2od76er4u6B7hh+7hfnigng8c7dk6RXTfTm8AVsYA2hKg2ePAo98zWFkp/laJbIBWK3DqZha2x0vzTh26kgHNba1TTvYqdKrvUzpVgj/q+DjLWC2RlRIaQAig+RPAoLkMVlaMv1kiK5WRV4SdZ2+NnUrJ0W+dqu/nohuI3i7Um61TRKbWZCDw9GYguA2g5PvNmjFcEVkJrVbgxI1M3azoR65m4LbGKTg7qNCpvm/pRZD9EOLN1ikikzuzCQhsBnjWke6HtJe3HqoRDFdEFiwttwg7zyYjNi4ZO+KTkZpbpLc+PMBVap0K90ObUC+o7fjXMlGNOfEr8OtYwKM28J9tgKuf3BVRDZE9XH399deYNWsWEhISEBkZiS+//BLt21ee7OfMmYNvv/0WV65cga+vLwYPHowZM2bA0dGxBqsmkodGK3DsWoauq+/otQyI21qnXNV26NzABz0i/NEt3A/Bnk7yFUtky46vAlY/K42zqtsZcPaWuyKqQbKGq+XLl2PChAmYO3cuOnTogDlz5iA6OhpxcXHw9/cvt/3SpUsxadIkzJ8/H506dUJ8fDyeeuopKBQKzJ49W4afgMj0UnIKsSNeClM74pORnlest75RoJtuIHqbul5wsONEhESyOrYSWPOsNDFoyyeBR77gGCsbI2u4mj17NsaOHYsxY8YAAObOnYuNGzdi/vz5mDRpUrnt9+zZg86dO2PEiBEAgNDQUAwfPhz//PNPjdZNZEoarcCRq+nYHpeM2PhkHL+eqdc65aa2Q5eGZWOn/BHowVZbIrNxbAWw5r9SsGr1JDDgS17WxgbJFq6Kiopw8OBBTJ48WbdMqVQiKioKe/furfAxnTp1ws8//4z9+/ejffv2uHDhAjZt2oRRo0ZV+jyFhYUoLLx1llRWVpbxfggiI0nKLsCOeGneqZ1nU5CZr9861STIXbpmX4Q/WtXxhL2KH9ZEZuf0hlvBqvVooP/nDFY2SrZwlZKSAo1Gg4CAAL3lAQEBOHPmTIWPGTFiBFJSUtClSxcIIVBSUoLnnnsOb731VqXPM2PGDLz77rtGrZ3ofpVotDh8NUN3zb6TN/RDv7ujHbqG+0mzoof7wd+drVNEZi+kPeAbDoR0APrPYbCyYbIPaDdEbGwsPvzwQ3zzzTfo0KEDzp07h5dffhnvvfcepk6dWuFjJk+ejAkTJujuZ2VlISQkpKZKJtJJzCrA9tKB6DvPJiOroERvffNgD900CS1DPGHH1ikiy+LqL81jpfZgsLJxsoUrX19fqFQqJCYm6i1PTExEYGBghY+ZOnUqRo0ahf/85z8AgObNmyM3NxfPPvsspkyZAmUFL2a1Wg21Wm38H4DoHoo1Why8nK47s+/0Tf3WKU9ne3RrKIWpbuF+8HPj65TI4hxZemt8FQA4eclbD5kF2cKVg4MD2rRpg23btmHQoEEAAK1Wi23btmH8+PEVPiYvL69cgFKppDMwxO0jfolkVKzRYvLq4/jjRAKyC2+1TikUQItgD3QvnRU9srYnVEqFjJUS0X05/DPwW+n3lW84JwglHVm7BSdMmICYmBi0bdsW7du3x5w5c5Cbm6s7e3D06NEIDg7GjBkzAAADBgzA7Nmz0apVK1234NSpUzFgwABdyCKS27bTSVh18BoAwNvFAd0a+qJHhD+6NvSFjytbp4iswqFFwLqXAAig3Vigdju5KyIzImu4Gjp0KJKTkzFt2jQkJCSgZcuW2Lx5s26Q+5UrV/Raqt5++20oFAq8/fbbuH79Ovz8/DBgwAB88MEHcv0IROWsP3YDADDqgbp495GmULJ1isi6HFwArH9Zut3+WaDPx1LTNFEphbCx/rSsrCx4eHggMzMT7u7uRt13SUkJNm/eDAB4+OGHYWdnUecLkBHkFpagzftbUFCsxfrxXdC8tofcJRGRMR34CdjwinS7w3PAwzMZrGxIVTMET2cgMqJtZ5JQUKxFqI8zmgUbN7wTkcyuHbgtWD3PYEWVYtMKkRGtPyp1CfZvUQsKfugSWZfgNkDnlwFNCRD9AYMVVYrhishIMvOLsT0uGQAwILKWzNUQkdFotdK8VQoFEFU6KTWDFd0FuwWJjOTPkwko0mgRHuCKiEA3ucshImPYPw9YMhgozpfuKxQMVnRPDFdERrL+2E0AwIAWbLUisgr/fAdsmgic3wYcXyV3NWRBGK6IjCA1pxC7z6UAAPqzS5DI8u37Fvj9Del2l1dvzcBOVAUcc0VkBL+fSIBGK9A82ANhvi5yl0NE92PvN8Afk6XbXSYAvaexK5AMwnBFZAQbSicOHRAZJHMlRHRf9n4N/PGWdLvrRKDX2wxWZDCGK6L7lJhVgH8upgEA+nG8FZHlykkGYj+Sbnd7Heg5hcGKqoXhiug+bTx2E0IAbep6IdjTSe5yiKi6XP2AUWuAC38DXV9jsKJqY7giuk9l1xIc0IJdgkQWKTsRcJOuaYvabaR/RPeBZwsS3YeraXk4fCUDSgXQl+GKyPLsnA181Q64fkjuSsiKMFwR3YcNpXNbPVDPB/5ujjJXQ0QG2fEJsO1doDATuLRL7mrIirBbkOg+3DpLkAPZiSzKjlnAX+9Lt3tNBTq/JG89ZFUYroiq6XxyDk7eyIKdUoGHmwbKXQ4RVdX2j4G/P5Bu954mDV4nMiKGK6Jq2nBU6hLs0tAXXi4OMldDRFUSOxOInSHdjnpHmn2dyMgYroiqQQiBdUevA+C1BIkshqYEuLJXuh31LtDlFVnLIevFcEVUDWcSsnE+ORcOdko82DRA7nKIqCpUdsCwX4D434Fmj8tdDVkxni1IVA3rj0oD2XtG+MHd0V7maoioUkIA5/+S/gcAB2cGKzI5hisiAwkhbk0cyrMEicyXEMBf7wGLH5X+J6oh7BYkMtCxa5m4mpYPZwcVejXyl7scIqqIENIcVrs+k+47+8pbD9kUhisiA5V1CfZuHABnB76FiMyOEMDWd4Ddc6T7D38EPPCcnBWRjeE3A5EBtFqhm5Wd1xIkMkNCAFumAXu+kO73mQV0eFbemsjmMFwRGeDA5XQkZBXAzdEO3SP85C6HiO60dfqtYNX3E6D9WHnrIZvEAe1EBijrEoxuGgi1nUrmaoioHJ8GgELJYEWyYssVURWVaLTYdLy0S5BnCRKZp9ajgZAHAL9wuSshG8aWK6Iq2nchDam5RfB2cUCn+j5yl0NEgDTGavfnQE7yrWUMViQzhiuiKirrEny4WSDsVXzrEMlOCOD3N6UB7IsGAiVFcldEBIDdgkRVUlSixe8nys4SZJcgkeyEADa9Dvw7D4BCmmrBjhdQJ/PAcEVUBTvPJiOroAT+bmq0D/OWuxwi2yYEsGki8O8PABTAI18CrUfJXRWRDsMVURWUdQn2axEElVIhczVENkyrlYLVgR8BKICBXwGtnpS7KiI9DFdE95BfpMGWU4kAeJYgkexiZ9wKVoO+AVqOkLsionI4KpfoHv6OS0JukQbBnk5oFeIpdzlEtq3Vk4BXKDDoWwYrMltsuSK6hw3HpC7B/pFBUCjYJUgkK6+6wAv/APaOcldCVCm2XBHdRU5hCbadTgLAswSJZKHVAhteBU6vv7WMwYrMHMMV0V1sPZWIwhIt6vm6oGktd7nLIbItWi2w7kXgwHzg1/8A2QlyV0RUJQxXRHdRdpZg/8ha7BIkqklaDbBuPHDkZ+lagQO/BtwC5a6KqEo45oqoEhl5RdhxVrqkxoAWQTJXQ2RDtBrgt/HA0aWAQgU8Pg9o9rjcVRFVGcMVUSX+OJmAYo1Ao0A3NAxwk7scItug1QBrXwCOLZOC1eAfgaaPyl0VkUEYrogqseFY6eVuOLcVUc05+sttwWo+0HSQ3BURGYzhiqgCKTmF2H0uBQDPEiSqUZEjgOsHgXo9gCYD5a6GqFoYrogq8Pvxm9AKILK2B+r4OMtdDpF105QAEIDKHlAqgf6fyV0R0X3h2YJEFVh/lF2CRDVCUwKseVaaakFTInc1REbBliuiO9zMzMf+S2kApAs1E5GJaEqA1f8BTq4BlPbAzSNA7bZyV0V03xiuiO6wsXQge/tQbwR5OMlcDZGV0hRLrVWn1krBasgiBiuyGgxXRHcomzh0QCRbrYhMQlMMrHoaOL1OClZDFwMRfeSuishoGK6IbnMlNQ9Hr2VCqQAebsZwRWR0mmJg1RjpWoEqB2DIYiDiYbmrIjIqhiui26w/JrVadarvCz83tczVEFmhpFPA2S1SsBq6BAh/SO6KiIyO4YroNuwSJDKxoEhgxHKpBavhg3JXQ2QSDFdEpc4mZuNMQjbsVQpEN+UFYomMpqQIyLoOeIdJ9+v1kLUcIlPjPFdEpdaXniXYraEfPJ0dZK6GyEqUFAIrRgM/PgQkx8tdDVGNYLgiAiCEwAZdlyAnDiUyipJCYPkoIP53oDALyL4hd0VENYLdgkQATt7IwoWUXKjtlIhqEiB3OUSWr7gAWDEKOPsnYOcIDF/G7kCyGQxXRAA2lHYJ9mrkD1c13xZE96W4AFj+JHBuC2DnBIxgsCLbwm8RsnlCiNvOEmSXINF9KS4Alo8Ezm0tDVbLgXrd5a6KqEYxXJHNO3w1A9cz8uHioELPCH+5yyGybJoiID8DsHcGRqwAwrrKXRFRjWO4IptX1mr1YJMAODmoZK6GyMI5ugOjVgMpZ3mtQLJZPFuQbJpGK3QXamaXIFE1FeUBJ1bfuu/owWBFNo0tV2TT9l9MQ1J2Idwd7dC1oZ/c5RBZnqI84JehwMUdQE4S8MBzcldEJDuGK7JpG0qvJfhws0A42LEhl8ggRbnA0qHApZ2AgytQq6XcFRGZBX6bkM0q1mjx+4kEAOwSJDKYXrByA55cDdR5QO6qiMwCW67IZu05n4q03CL4uDigYz0fucshshxFucCSIcDlXVKwGrUaCGkvd1VEZoPhimxW2VmCfZsHwU7FRlyiKtGUAEueAC7vBtTuUotVSDu5qyIyK/xGIZtUWKLBH+wSJDKcyg5o+BCg9gBGrWGwIqoAW67IJm2PS0Z2YQkC3R3Rtq6X3OUQWZYurwCRwwE3XoeTqCJsuSKbtL50bqv+LYKgVCpkrobIzBVkARsnSv+XYbAiqhRbrsjm5BWVYOupRABAf3YJEt1dQRbw8+PAtf1AxmVg5Eq5KyIye2y5Ipvz15kk5BdrEOLthMjaHnKXQ2S+CjKBnx+TgpWjJ9BzitwVEVkEtlyRzSk7S3BAi1pQKNglSFShgkxg8WPA9QNSsBr9GycJJaoihiuyKVkFxfg7LhkAzxIkqlR+htRidf0g4OQlBaugSLmrIrIYDFdkU7acTERRiRYN/F3RKNBN7nKIzNOa50qDlTcQsw4IbC53RUQWheGKbMr6Y+wSJLqnqHeA9EvA4/MYrIiqgeGKbEZ6bhF2nU0BAPSPDJK5GiIzIwRQ9geHfyPg+T2Akuc8EVUH3zlkMzafTECJVqBJkDvq+7nKXQ6R+chLA37qA1zYfmsZgxVRtfHdQzZDd5YgB7IT3ZKXBix6BLiyF1g3HigpkrsiIovHbkGyCUlZBdh7IRWANCs7EQHITQUWDQQSjwMufsCIFYCdg9xVEVm8+2q5KigoMFYdRCa16fhNCAG0quOJEG9nucshkl9uqtRilXgccPEHYjYA/o3lrorIKhgcrrRaLd577z0EBwfD1dUVFy5cAABMnToVP/74o9ELJDKGsmsJDmjBLkEi5KYACwcAiSekYPXUBmkQOxEZhcHh6v3338eCBQvw8ccfw8HhVvNxs2bN8MMPPxi1OCJjuJ6Rj4OX06FQAP3YJUgE7PkSSDoJuAYAT20E/CLkrojIqhgcrhYtWoTvv/8eI0eOhEql0i2PjIzEmTNnjFockTFsLJ3bqn2oNwLcHWWuhsgM9HobaPtMabAKl7saIqtj8ID269evo0GDBuWWa7VaFBcXG6UoImNaf7S0S5BnCZIty88A1O7SFAsqe6D/bLkrIrJaBrdcNWnSBDt37iy3fNWqVWjVqpVRiiIylospuTh+PRMqpQJ9mgXKXQ6RPHKSgPnRwMZXAa1W7mqIrJ7BLVfTpk1DTEwMrl+/Dq1Wi9WrVyMuLg6LFi3Chg0bTFEjUbVtKJ3bqnMDX/i4qmWuhkgG2YnS4PWUOKAgC+iRBLjxDw0iUzK45WrgwIFYv349tm7dChcXF0ybNg2nT5/G+vXr8eCDD5qiRqJqu3UtQQ5kJxuUnQAs7C8FK/dg6axABisik6vWJKJdu3bFli1bjF0LkVHFJWQjPjEHDiolHmrKLxSyMdkJwIL+QOpZwL028NR6wLue3FUR2QSDW67q1auH1NTUcsszMjJQr57hb9yvv/4aoaGhcHR0RIcOHbB///67bp+RkYFx48YhKCgIarUa4eHh2LRpk8HPS9ZvQ2mrVbdwP3g42ctcDVENyroJLOgnBSuPEKnFisGKqMYY3HJ16dIlaDSacssLCwtx/fp1g/a1fPlyTJgwAXPnzkWHDh0wZ84cREdHIy4uDv7+/uW2LyoqwoMPPgh/f3+sWrUKwcHBuHz5Mjw9PQ39McjKCSFuu5YguwTJxiQcB9Iv3QpWXqFyV0RkU6ocrtatW6e7/ccff8DDw0N3X6PRYNu2bQgNDTXoyWfPno2xY8dizJgxAIC5c+di48aNmD9/PiZNmlRu+/nz5yMtLQ179uyBvb3UEnGv5ywsLERhYaHuflZWlkE1kmU6cT0Ll1Lz4GivRFTjALnLIapZ4Q8BQ3+WLmfDYEVU46ocrgYNGgQAUCgUiImJ0Vtnb2+P0NBQfPrpp1V+4qKiIhw8eBCTJ0/WLVMqlYiKisLevXsrfMy6devQsWNHjBs3Dr/99hv8/PwwYsQIvPnmm3oTmt5uxowZePfdd6tcF1mHsoHsvRsHwEXN65OTDci8Bggt4FlHuh/RR956iGxYlcdcabVaaLVa1KlTB0lJSbr7Wq0WhYWFiIuLQ//+/av8xCkpKdBoNAgI0G9VCAgIQEJCQoWPuXDhAlatWgWNRoNNmzZh6tSp+PTTT/H+++9X+jyTJ09GZmam7t/Vq1erXCNZJq1W6KZg4LUEySZkXJXGWC3oL90mIlkZ/Cf9xYsXTVFHlWi1Wvj7++P777+HSqVCmzZtcP36dcyaNQvTp0+v8DFqtRpqNec3siWHrqTjRmYBXNV26BHhJ3c5RKZVFqwyLrMLkMhMVKu/JDc3F9u3b8eVK1dQVFSkt+6ll16q0j58fX2hUqmQmJiotzwxMRGBgRWfNh8UFAR7e3u9LsDGjRsjISEBRUVFeheSJttVNpD9oSYBcLSvuLuYyCpkXCltrboMeIVJg9c9astdFZHNMzhcHT58GH379kVeXh5yc3Ph7e2NlJQUODs7w9/fv8rhysHBAW3atMG2bdt047m0Wi22bduG8ePHV/iYzp07Y+nSpdBqtVAqpR7N+Ph4BAUFMVgRAECjFdh4XOpW5rUEyaqlX5YmCM24Ik2zELMB8AiWuyoiQjXmuXr11VcxYMAApKenw8nJCfv27cPly5fRpk0bfPLJJwbta8KECZg3bx4WLlyI06dP4/nnn0dubq7u7MHRo0frDXh//vnnkZaWhpdffhnx8fHYuHEjPvzwQ4wbN87QH4Os1D8XUpGSUwhPZ3t0buArdzlEppF+ubTF6grgXR94aiODFZEZMbjl6siRI/juu++gVCqhUqlQWFiIevXq4eOPP0ZMTAwee+yxKu9r6NChSE5OxrRp05CQkICWLVti8+bNukHuV65c0bVQAUBISAj++OMPvPrqq2jRogWCg4Px8ssv48033zT0xyArVXaWYJ9mgXCwM/hvByLLYO8MODgDPg2AmPWAO1tpicyJweHK3t5eF3j8/f1x5coVNG7cGB4eHtU6E2/8+PGVdgPGxsaWW9axY0fs27fP4Och61dUosXvJ0q7BHmWIFkzVz8pVGk1gDsnySUyNwaHq1atWuHff/9Fw4YN0b17d0ybNg0pKSlYvHgxmjVrZooaiapk97kUZOQVw9dVjQ71fOQuh8i40i4A1w4CLZ6Q7ruWv4oFEZkHg/tNPvzwQwQFSX8pffDBB/Dy8sLzzz+P5ORkfPfdd0YvkKiqys4S7N8iCCqlQuZqiIwo9TzwUz9g9Vjg5Bq5qyGiezC45apt27a62/7+/ti8ebNRCyKqjoJiDf48JU3r0b8Fu0nIiqSelwavZ98A/BoBdTvLXRER3YPRRvweOnTIoBnaiYwpNi4ZOYUlqOXhiNZ1vOQuh8g4Us5JE4SWBauY9ewOJLIABoWrP/74AxMnTsRbb72FCxcuAADOnDmDQYMGoV27dtBqtSYpkuheys4S7B9ZC0p2CZI1SDlbGqxuAn6NpXmsGKyILEKVuwV//PFHjB07Ft7e3khPT8cPP/yA2bNn48UXX8TQoUNx4sQJNG7c2JS1ElUot7AE205LXYI8S5CsQk6y1BWYkwD4N5FarFw4bxuRpahyy9Xnn3+Ojz76CCkpKVixYgVSUlLwzTff4Pjx45g7dy6DFclm6+lEFBRrEerjjGbB7nKXQ3T/XHyByKGAf1MGKyILVOWWq/Pnz+OJJ6RTgB977DHY2dlh1qxZqF2b17Eiea0/ehOAdLkbhYJdgmQFFAog6l2g2xuA2lXuaojIQFVuucrPz4ezszMAQKFQQK1W66ZkIJJLZn4xtscnAQD6s0uQLFnSGeDXsUBxvnRfoWCwIrJQBk3F8MMPP8DVVXqzl5SUYMGCBfD11W+uruqFm4mM4c+TCSjWCIQHuCIi0E3ucoiqJ/EUsHAAkJcCOPsAfWbKXRER3Ycqh6s6depg3rx5uvuBgYFYvHix3jYKhYLhimrU+mOlXYJstSJLdXuwCmwBdH9D7oqI6D5VOVxdunTJhGUQGS41pxC7z6UAkKZgILI4iSdLg1UqEBQJjFoLOHvLXRUR3SeDZ2gnMhe/n0iARivQPNgDYb4ucpdDZJiE48DCR4D8NCCoJTB6LeDECXCJrIHRZmgnqmll1xIcEMkTK8jCaEqA5aOkYFWrFYMVkZVhuCKLlJBZgP2X0gAA/TjeiiyNyg54/EegXk+pK5DBisiqsFuQLNLG4zchBNCmrheCPZ3kLoeoajTFgMpeul27jdRiRURWhy1XZJE2lF5LcEALdgmShbhxBPiqLXD9oNyVEJGJVStcnT9/Hm+//TaGDx+OpCRpAsfff/8dJ0+eNGpxRBW5mpaHw1cyoFQAfRmuyBLcOAwsGgikXwL+niF3NURkYgaHq+3bt6N58+b4559/sHr1auTk5AAAjh49iunTpxu9QKI7bSid2+qBej7wd3OUuRqie7h+SApWBRlASAdg8Hy5KyIiEzM4XE2aNAnvv/8+tmzZAgcHB93yXr16Yd++fUYtjqgit84S5EB2MnPXDwKLBgEFmUDIA8CTvwKOvLg4kbUzOFwdP34cjz76aLnl/v7+SElJMUpRRJU5l5SDUzezYKdU4OGmgXKXQ1S5aweBRY8ChZlAnY7Ak6sANS/RRGQLDA5Xnp6euHnzZrnlhw8fRnBwsFGKIqpM2UD2Lg194eXicI+tiWS05/PSYNUJGMlgRWRLDA5Xw4YNw5tvvomEhAQoFApotVrs3r0bEydOxOjRo01RIxEAQAhxq0uQc1uRuXv0O6DzK8DIlYDaVe5qiKgGGRyuPvzwQzRq1AghISHIyclBkyZN0K1bN3Tq1Alvv/22KWokAgCcScjG+eRcONgp8WDTALnLISov4woghHTb3gl48F0GKyIbZPAkog4ODpg3bx6mTp2KEydOICcnB61atULDhg1NUR+RTlmrVc8IP7g72stcDdEdruwDfn4caD8W6D0dUCjkroiIZGJwuNq1axe6dOmCOnXqoE6dOqaoiagcIQTWH+NZgmSmLu8FlgwGinKkMwQ1xYAdxwQS2SqDuwV79eqFsLAwvPXWWzh16pQpaiIq5+i1TFxNy4ezgwq9GvnLXQ7RLZf3SC1WRTlAWHdg+HIGKyIbZ3C4unHjBl577TVs374dzZo1Q8uWLTFr1ixcu3bNFPURAbjVJRjVOADODrwkJpmJS7uBnwcDxblAvR7AiOWAg7PcVRGRzAwOV76+vhg/fjx2796N8+fP44knnsDChQsRGhqKXr16maJGsnFarcDG0lnZ+/NyN2QuLu2SugKLc4F6PYHhy6RB7ERk8+7rws1hYWGYNGkSZs6ciebNm2P79u3GqotI58DldCRkFcDN0Q7dI/zkLodIkn4ZKM4D6vcGhv/CYEVEOtXuX9m9ezeWLFmCVatWoaCgAAMHDsSMGbwgKRlfWZdgdNNAqO1UMldDVKrVSMDFDwjrBtjzGpdEdIvB4Wry5MlYtmwZbty4gQcffBCff/45Bg4cCGdnjjMg4yvRaLHpuNQlyLMESXaX9wA+DQHX0hbU8IfkrYeIzJLB4WrHjh14/fXXMWTIEPj6+pqiJiKdvRdSkZpbBG8XB3Sq7yN3OWTLzv8N/DIM8K4HPLURcPaWuyIiMlMGh6vdu3ebog6iCpV1CfZpFgh71X0NESSqvnPbgGUjgJICwLMO4OAid0VEZMaqFK7WrVuHPn36wN7eHuvWrbvrto888ohRCiMqKtFi84kEAEB/XkuQ5HJuK/DLCEBTCIT3AYYsBOzUcldFRGasSuFq0KBBSEhIgL+/PwYNGlTpdgqFAhqNxli1kY3beTYZWQUl8HdTo30Yu2BIBme3Si1WmkIgoh/wxAJOEEpE91SlcKXVaiu8TWRKZV2C/VoEQaXkddqohp3/+1awatQfGPwTgxURVYnBg1gWLVqEwsLCcsuLioqwaNEioxRFlF+kwZZTiQB4liDJxKc+4BYANB7AFisiMojB4WrMmDHIzMwstzw7OxtjxowxSlFEf8clIbdIg2BPJ7QK8ZS7HLJFnnWAp/+UWqxU9nJXQ0QWxOCzBYUQUCjKd9Fcu3YNHh4eRimKqKxLcEBkrQpfb0QmEfc7oC2RWqsAwJ2XWyIiw1U5XLVq1QoKhQIKhQK9e/eGnd2th2o0Gly8eBEPP/ywSYok25JdUIy/ziQB4LUEqQad2QSsGA1AAGM2AyHt5K6IiCxUlcNV2VmCR44cQXR0NFxdXXXrHBwcEBoaiscff9zoBZLt2Xo6EYUlWtTzdUHTWu5yl0O24PQGYOVTgLYYaPoYUKuV3BURkQWrcriaPn06ACA0NBRDhw6FoyOvpUWmseGodLmb/uwSpJpwen1psCoBmj0OPPo9oKr2ZVeJiAwfcxUTE2OKOogAABl5RdhxNhkAMIBdgmRqp9YBq8aUBqvBwKPfMVgR0X2r0qeIt7c34uPj4evrCy8vr7u2JqSlpRmtOLI9f5xMQLFGoFGgGxoGuMldDlmz64ekFiuhAZoPAQZ9y2BFREZRpU+Szz77DG5ubrrb7KohU1lf2iXIua3I5IJaAq1GAiWFUrBSquSuiIisRJXC1e1dgU899ZSpaiEbl5xdiD3nUwAAA3gtQTI1pRLo/zkAwWBFREZl8CSihw4dwvHjx3X3f/vtNwwaNAhvvfUWioqKjFoc2ZbfT9yEVgCRtT1Qx8dZ7nLIGp34FVj1NKAplu4rlQxWRGR0Boer//73v4iPjwcAXLhwAUOHDoWzszNWrlyJN954w+gFku3YwC5BMqXjq4Bf/yMFrMOL5a6GiKyYweEqPj4eLVu2BACsXLkS3bt3x9KlS7FgwQL8+uuvxq6PbMTNzHzsvySdDNGPZwmSsR1bCaweCwgt0OpJoPVTcldERFbM4HAlhIBWqwUAbN26FX379gUAhISEICUlxbjVkc3YeExqtWof6o0gDyeZqyGrcmwFsOZZKVi1Hg0M+FLqDiQiMhGDP2Hatm2L999/H4sXL8b27dvRr18/AMDFixcREBBg9ALJNty6liBbrciIji4D1vy3NFjFSAPYGayIyMQM/pSZM2cODh06hPHjx2PKlClo0KABAGDVqlXo1KmT0Qsk63c5NRdHr2VCqQD6NGe4IiPJTQE2TJCCVZungP5zGKyIqEYYPGNeixYt9M4WLDNr1iyoVDzrhgy3obRLsFN9X/i6qmWuhqyGiy8wfCkQtxmI/pDBiohqTLWnIz548CBOnz4NAGjSpAlat25ttKLItrBLkIyqMBtQl87uX6+H9I+IqAYZHK6SkpIwdOhQbN++HZ6engCAjIwM9OzZE8uWLYOfn5+xayQrdjYxG2cSsmGvUiC6aaDc5ZClO7QI+OsDIGYd4BchdzVEZKMMbid/8cUXkZOTg5MnTyItLQ1paWk4ceIEsrKy8NJLL5miRrJi60u7BLs19IOns4PM1ZBFO7gQWPcikJMAHF8pdzVEZMMMbrnavHkztm7disaNG+uWNWnSBF9//TUeeughoxZH1k0IgQ26LkFOHEr34cBPwIZXpNsdngN6TpG1HCKybQa3XGm1Wtjb25dbbm9vr5v/iqgqTt7IwoWUXKjtlIhqwmk8qJoOzL8tWD0PPDwT4MXliUhGBoerXr164eWXX8aNGzd0y65fv45XX30VvXv3NmpxZN3WH5NeQ70b+8NVXe1zK8iW/fsjsOFV6fYD44CHZzBYEZHsDA5XX331FbKyshAaGor69eujfv36CAsLQ1ZWFr788ktT1EhWSOoSlMZb9W/BLkGqBk0JcPQX6XbH8UD0BwxWRGQWDG4uCAkJwaFDh7Bt2zbdVAyNGzdGVFSU0Ysj63X4agauZ+TDxUGFnhH+cpdDlkhlBzz5K3B0OdB+LIMVEZkNg8LV8uXLsW7dOhQVFaF379548cUXTVUXWbmyua0ebBIAJwdOPksGuHkUCIqUbjt6AB2elbceIqI7VLlb8Ntvv8Xw4cNx4MABnD17FuPGjcPrr79uytrISmm0QnehZp4lSAbZ9y3wXTdgD4cgEJH5qnK4+uqrrzB9+nTExcXhyJEjWLhwIb755htT1kZWav/FNCRlF8Ld0Q5dG3LSWaqivV8DmydJt/PS5K2FiOguqhyuLly4gJiYGN39ESNGoKSkBDdv3jRJYWS9ys4S7NMsCA52vN4bVcGer4A/3pJud50I9J4mbz1ERHdR5TFXhYWFcHFx0d1XKpVwcHBAfn6+SQoj61Ss0eL346VnCfJaglQVe74E/nxbut3tdWmCUA5eJyIzZtCA9qlTp8LZ2Vl3v6ioCB988AE8PDx0y2bPnm286sjq7D6XgvS8Yvi4OKBjPR+5yyFzt/tzYEtpK1X3N4EekxmsiMjsVTlcdevWDXFxcXrLOnXqhAsXLujuK/ihR/ewoXQge9/mQbBTsUuQ7qX0M6X7JKDnZHlLISKqoiqHq9jYWBOWQbagsESDP04kAOBZglRFnV8CQtoDdR6QuxIioipj0wHVmO1xycguLEGguyPa1vWSuxwyV4eXAAWZt+4zWBGRhWG4ohqz/ljZ5W6CoFSyC5kqsH0W8NsLwM+PAyVFcldDRFQtvFou1Yi8ohJsPZUIgF2CVInYj4DYD6XbEX0AOwd56yEiqiaGK6oR204nIb9YgzrezmhR2+PeDyDbEjsTiJ0h3e49Heg6Qd56iIjuA8MV1Yiyawn2bxHEs0rpFiGkULX9I+l+1LtAl1dkLYmI6H5Va8zVzp078eSTT6Jjx464fv06AGDx4sXYtWuXUYsj65BVUIzY+GQA7BKkO+z+/FawevA9BisisgoGh6tff/0V0dHRcHJywuHDh1FYWAgAyMzMxIcffmj0AsnybTmZiKISLRr4u6JRoJvc5ZA5CX8YcPEDHnpfmnaBiMgKGByu3n//fcydOxfz5s2Dvb29bnnnzp1x6NAhoxZH1qHsWoIDWtRilyDp828EjNsPdHpR7kqIiIzG4HAVFxeHbt26lVvu4eGBjIwMY9REViQttwi7zqYA4LUECdIYq78/BC7E3lrm7C1bOUREpmBwuAoMDMS5c+fKLd+1axfq1atnlKLIemw+kYASrUCTIHfU93OVuxySkxDA1nekMVa/DAeybshdERGRSRgcrsaOHYuXX34Z//zzDxQKBW7cuIElS5Zg4sSJeP75501RI1mwsrMEOZDdxgkhXYB59xzpftS7gDtfE0RknQyeimHSpEnQarXo3bs38vLy0K1bN6jVakycOBEvvshxE3RLUlYB9l1MBSBNwUA2Sghgy1Rgz5fS/b6fAO3HylsTEZEJGRyuFAoFpkyZgtdffx3nzp1DTk4OmjRpAldXdvmQvk3Hb0IIoFUdT4R4O8tdDslBCODPt4G9X0n3GayIyAZUexJRBwcHNGnSxJi1kJUpu5bggBbs/rFZR5fdClb9ZgPtnpG3HiKiGmBwuOrZs+ddT6f/66+/DC7i66+/xqxZs5CQkIDIyEh8+eWXaN++/T0ft2zZMgwfPhwDBw7E2rVrDX5eMp1r6Xk4eDkdCgXQj12Ctqv5YCB+M1CvB9B2jNzVEBHVCIPDVcuWLfXuFxcX48iRIzhx4gRiYmIMLmD58uWYMGEC5s6diw4dOmDOnDmIjo5GXFwc/P39K33cpUuXMHHiRHTt2tXg5yTT21jaatUhzBsB7o4yV0M1Sgjpn1IJqOyBJxYAnN+MiGyIweHqs88+q3D5O++8g5ycHIMLmD17NsaOHYsxY6S/aufOnYuNGzdi/vz5mDRpUoWP0Wg0GDlyJN59913s3LmT82uZobKJQ/uzS9C2CAH8/gZQUgj0nyMFLAYrIrIx1bq2YEWefPJJzJ8/36DHFBUV4eDBg4iKirpVkFKJqKgo7N27t9LH/e9//4O/vz+eeebe4zcKCwuRlZWl949M62JKLk5cz4JKqUCfZoFyl0M1RQhg00Rg//fAoUXA1X/kroiISBZGC1d79+6Fo6Nh3T8pKSnQaDQICAjQWx4QEICEhIQKH7Nr1y78+OOPmDdvXpWeY8aMGfDw8ND9CwkJMahGMtyG0rmtOjfwhY+rWuZqqEZotcDG14B/fwCgAAZ+BdTtKHdVRESyMLhb8LHHHtO7L4TAzZs3ceDAAUydOtVohVUkOzsbo0aNwrx58+Dr61ulx0yePBkTJkzQ3c/KymLAMrFb1xLkQHaboNUCGycAB3+CFKy+BlqNlLsqIiLZGByuPDw89O4rlUpERETgf//7Hx566CGD9uXr6wuVSoXExES95YmJiQgMLN+ddP78eVy6dAkDBgzQLdNqtQAAOzs7xMXFoX79+nqPUavVUKvZelJT4hKyEZ+YAweVEg81ZZeg1dNqgY2vAgcXAFAAg74FWg6XuyoiIlkZFK40Gg3GjBmD5s2bw8vL676f3MHBAW3atMG2bdswaNAgAFJY2rZtG8aPH19u+0aNGuH48eN6y95++21kZ2fj888/Z4uUGSi73E33CD94ONnLXA2ZXMJR4PDPgEIJDJoLRA6VuyIiItkZFK5UKhUeeughnD592ijhCgAmTJiAmJgYtG3bFu3bt8ecOXOQm5urO3tw9OjRCA4OxowZM+Do6IhmzZrpPd7T0xMAyi2nmieEuO0sQXYJ2oRarYDBPwElBUCLIXJXQ0RkFgzuFmzWrBkuXLiAsLAwoxQwdOhQJCcnY9q0aUhISEDLli2xefNm3SD3K1euQKk02rh7MqHj1zNxOTUPjvZKRDUOuPcDyDJptUBeCuBaOg9dk0fkrYeIyMwYHK7ef/99TJw4Ee+99x7atGkDFxcXvfXu7u4GFzF+/PgKuwEBIDY29q6PXbBggcHPR6axoXTi0N6NA+CirvaVlcicaTXAuheBSzuBpzYCnnXkroiIyOxU+Rvwf//7H1577TX07dsXAPDII4/oXQZHCAGFQgGNRmP8KsnsabVCNwUDryVopbQa4LdxwNFfAIUKuHmM4YqIqAJVDlfvvvsunnvuOfz999+mrIcs1KEr6biRWQBXtR16RPjJXQ4Zm1YDrH0BOLZMClaP/wA07i93VUREZqnK4UoIAQDo3r27yYohy1V2luBDTQPgaK+SuRoyKq0GWPMccHyFFKwG/wg0fVTuqoiIzJZBA2MUvEYYVaBEo8XG49J4K3YJWhlNCbD2OeD4SkBpBwyeDzQZKHdVRERmzaBwFR4efs+AlZaWdl8FkeX552IaUnKK4Olsj84NqjZzPlmIwiwg4URpsPqJZwYSEVWBQeHq3XffLTdDO1FZl2CfZoFwsOO0GVbF2RuIWQ/cPAo0jLr39kREZFi4GjZsGPz9/U1VC1mgohItNp+ULrLNLkEroSkBLu8C6vWQ7rv6MVgRERmgys0MHG9FFdl9LgUZecXwdVWjQz0fucuh+6UpBn59Blg0SLqsDRERGczgswWJblfWJdi/RRBUSgZwi6YpBlY9DZxeB6gcAGeOnyMiqo4qhyutVmvKOsgCFRRr8OepRADAgEheS9CiaYqBVWOA0+ulYDX0ZyA8Wu6qiIgsEq9RQtUWG5eEnMIS1PJwRKsQ41zIm2RQUiQFqzMbSoPVEiD8IbmrIiKyWAxXVG3rj0pzW/WPrAUluwQtk6bktmClBoYtARo+KHdVREQWjeGKqiW3sATbzpR2CfIsQculVAE+DUqD1VKeFUhEZAQMV1QtW08noqBYi1AfZzQLdpe7HKouhQKIegdo9STg21DuaoiIrAJnfKRqKesSHBBZi9N0WJqSQiB2JlCcL91XKBisiIiMiC1XZLDMvGJsj08CIIUrsiDFBcCKUcDZP4GE49IYKyIiMiqGKzLYH6cSUKwRCA9wRXiAm9zlUFUVFwDLnwTObQHsnID2z8pdERGRVWK4IoOVTRzKgewWpLgAWDYCOL9NClYjVwBh3eSuiojIKjFckUFScwqx53wqAGkKBrIAxfmlweovwN4ZGLECCOsqd1VERFaL4YoM8vuJBGi0As2DPRDm6yJ3OVQVa54rDVYuwMiVQGhnuSsiIrJqPFuQDKLrEuTlbixHp5cAt1rAk6sYrIiIagBbrqjKEjILsP9SGgCgH8dbWY7abYCXDgP2jnJXQkRkE9hyRVW28fhNCAG0reuFYE8nucuhyhTlAstGAtcO3lrGYEVEVGMYrqjKyroE+7dgl6DZKsoFlg6VrhW4YrQ0YSgREdUodgtSlVxNy8ORqxlQKoC+DFfmqSgXWDIEuLwLcHADBs8H7NRyV0VEZHMYrqhKNhyTLnfzQD0f+Luxi8nsFOYAS4cAl3cDanfgydVASDu5qyIiskkMV1Qlt84S5EB2s1OYDSx5AriyVwpWo9YAtdvKXRURkc3imCu6p3NJOTh1Mwt2SgUebhoodzl0px2zSoOVBzBqLYMVEZHM2HJF97ThmNRq1bWhL7xcHGSuhsrpMRlIvwx0fgkIbiN3NURENo/hiu5KCHHbWYLsEjQbxQXSYHWFArB3AoYslLsiIiIqxW5BuqvTN7NxPjkXDnZKPNg0QO5yCAAKMoGF/YFt7wJCyF0NERHdgeGK7mp9aZdgzwg/uDvay1wNoSATWPwYcO1f4MBPQPZNuSsiIqI7sFuQKiWE0I234lmCZiA/A/j5MeD6QcDJCxj9G+DO3wsRkblhuKJKHb2Wiatp+XB2UKFXI3+5y7Ft+RnA4keBG4dKg9U6IKiF3FUREVEFGK6oUmUD2aMaB8DZgS8V2eSnlwarw4CTNxCzDghsLndVRERUCX5jUoW0WnYJmo1Lu4AbRwBnH6nFKrCZ3BUREdFdMFxRhf69lIbErEK4OdqhW7iv3OXYtsYDgEHfSt2AAU3lroaIiO6B4YoqVHaWYHTTQKjtVDJXY4Py0gBtCeBaOtat5XB56yEioirjVAxUTolGi9+PJwBgl6As8tKARY8ACwcAOclyV0NERAZiuKJy9l5IRWpuEbxdHNCpvo/c5diW3FRg4SNAwnEpZOWny10REREZiN2CVE7ZWYJ9mgXCXsX8XWNyU6UWq8QTgIs/8NQGwC9c7qqIiMhADFekp7BEg80n2CVY43JTpBarpJOAawAQw2BFRGSpGK5Iz874FGQVlMDfTY12od5yl2MbcpKlFqukU4BroNRi5dtQ7qqIiKiaGK5IT9lZgv1aBEGlVMhcjY0oKQCKcgC3IKnFyreB3BUREdF9YLginfwiDbacSgTALsEa5RkihSpNMYMVEZEV4Ghl0vk7Lgl5RRoEezqhVYin3OVYt+xE4OyWW/e96jJYERFZCYYr0ik7S3BAZC0oFOwSNJnsBGBhf+CXYUDcZrmrISIiI2O4IgBAdkEx/jqTBAAYEBkkczVWLDsBWNAfSImXBq/7RchdERERGRnHXBEAYOvpRBSWaFHP1wVNgtzlLsc6Zd2UWqxSzwEeIUDMesA7TO6qiIjIyBiuCACw/uhNAEB/dgmaRtYNqcUq7TzgUQd4aj3gFSp3VUREZAIMV4SMvCLsiJeuYTegBbsEjS4v7Vaw8qwjnRnoVVfuqoiIyEQYrgibTySgRCvQKNANDQPc5C7H+jh6AqFdAG0x8NRGKWAREZHVYrgibDgmdQlybisTUSqB/nOAvFTA1U/uaoiIyMR4tqCNS84uxJ7zKQCAAS0Yrowm4yrw+yRpYlBAClgMVkRENoEtVzbu9xM3oRVAZIgn6vg4y12OdUi/LJ0VmHEFUCiBhz+UuyIiIqpBDFc2TjdxKAeyG0f6ZWnweuYVwCsM6DhO7oqIiKiGMVzZsBsZ+fj3UjoA6ULNdJ/SLwELBkjByrueNHjdnV2tRES2hmOubNjG0oHs7UO9EeThJHM1Fi7t4q0WK+/6DFZERDaMLVc2bMOxsmsJstXqvmhKgCVPAJlXAZ8G0jxW7jymRES2ii1XNupyai6OXsuEUgH0ac4gcF9UdkC/T4DAFqUtVjyeRES2jC1XNqpsbqvODXzh66qWuRoLJQRQdqmgej2AZ7dLUy4QEZFN4zeBjSo7S7A/B7JXT+p54PseQHLcrWUMVkREBIYrmxSfmI0zCdmwVykQ3TRQ7nIsT+p5YEE/4OYRYNNEuashIiIzw25BG7ShtNWqW0M/eDo7yFyNhUk5K50VmJMA+DUGHv9R7oqIiMjMMFzZGCEE1vNagtWTHA8sHCAFK/8mwOh1vKQNERGVw3BlY07eyMLFlFyo7ZSIahIgdzmWIzmuNFglAv5NgZh1gIuv3FUREZEZ4pgrG7O+dG6r3o394apmtq6yre9KwSqgGYMVERHdFcOVDRFCYMPR0i7BFuwSNMij3wKtnpS6AhmsiIjoLth0YUMOXcnA9Yx8uDio0LORv9zlmL+8NMDZW7rt6AEM/FreeoiIyCKw5cqGlM1t9WCTADjaq2SuxswlngK+agfs/kLuSoiIyMIwXNkIjVZg43GeJVgliSeBhf2BvBTgxCqgpFDuioiIyIIwXNmI/RfTkJxdCHdHO3RtyOkDKpVwQjorMC8VCGoJjP4NsOPlgYiIqOo45spGlJ0l2KdZEBzsmKkrlHAcWPgIkJ8G1GoFjFoDOHnJXRUREVkYhisbUKzR4nd2Cd7dzWPAokeA/HSgVuvSYOUpd1VERGSBGK5swO5zKUjPK4aPiwMeqOctdznm6co+KVgFt5GClaOH3BUREZGFYriyAetL57bq2zwIdip2CVaow7NSoIp4mMGKiIjuC79prVxBsQZ/nkwAwC7BchJOAAWZt+5HDmWwIiKi+8ZwZeW2xycju7AEge6OaFuXg7N1rh8CFvQFFj8GFGTJXQ0REVkRhisrt+GY1CXYv0UQlEqFzNWYiesHgUWDpFYrpR2g4HEhIiLj4ZgrK5ZXVIKtpxIBsEtQ59pBYPEgoDALqNMRGLkSULvJXRUREVkRtlxZsW2nk5BfrEEdb2e0qM2xRLh24LZg1QkYuYrBioiIjI4tV1as7FqC/VsEQWHrXV9X/wUWPwoUZQN1OwMjVgBqV7mrIiIiK8RwZaWyCooRG5cMgF2CAABHd8DeCajVEhixHHBwkbsiIiKyUgxXVurPk4ko0mjRwN8VjQLZ9QW/CODpzYBbIIMVERGZFMOVldpQei3BAS1q2W6X4OU9gKYIqNdDuu9TX9ZyiIjINpjFgPavv/4aoaGhcHR0RIcOHbB///5Kt503bx66du0KLy8veHl5ISoq6q7b26K03CLsOpsCAOgfGSRzNTK5tBv4eTCwdJg09QIREVENkT1cLV++HBMmTMD06dNx6NAhREZGIjo6GklJSRVuHxsbi+HDh+Pvv//G3r17ERISgoceegjXr1+v4crN1+YTCSjRCjSt5Y76fjY4aPvSLmDJE0BxLlDnAcC/idwVERGRDZE9XM2ePRtjx47FmDFj0KRJE8ydOxfOzs6YP39+hdsvWbIEL7zwAlq2bIlGjRrhhx9+gFarxbZt2yrcvrCwEFlZWXr/rN2tswRtcCD7xZ23glX9XsDwX6SB7ERERDVE1nBVVFSEgwcPIioqSrdMqVQiKioKe/furdI+8vLyUFxcDG9v7wrXz5gxAx4eHrp/ISEhRqndXCVlFWDfxVQA0hQMNuXijtJglQfU7w0MW8pgRURENU7WcJWSkgKNRoOAgAC95QEBAUhISKjSPt58803UqlVLL6DdbvLkycjMzNT9u3r16n3Xbc42Hr8JIYBWdTwR4u0sdzk1J+E4sGQIUJIPNIhisCIiItlY9NmCM2fOxLJlyxAbGwtHR8cKt1Gr1VCr1TVcmXzKugQH2FqXoF8jIPwhoCgPGPozYF/x64GIiMjUZA1Xvr6+UKlUSExM1FuemJiIwMDAuz72k08+wcyZM7F161a0aNHClGVajGvpeTh0JQMKBdDP1roEVfbA4z8CQgvY2U6YJiIi8yNrt6CDgwPatGmjNxi9bHB6x44dK33cxx9/jPfeew+bN29G27Zta6JUi7Dx2E0AQIcwbwS420DLzfm/gE2vA1qtdF9lz2BFRESyk71bcMKECYiJiUHbtm3Rvn17zJkzB7m5uRgzZgwAYPTo0QgODsaMGTMAAB999BGmTZuGpUuXIjQ0VDc2y9XVFa6uNjjtwG3Wl00caguXuzm3FfhlBKAplLoE2z0jd0VEREQAzCBcDR06FMnJyZg2bRoSEhLQsmVLbN68WTfI/cqVK1AqbzWwffvttygqKsLgwYP19jN9+nS88847NVm6WbmQnIMT17OgUirQp5mVdwme3QosKw1WEf2AVqPkroiIiEhH9nAFAOPHj8f48eMrXBcbG6t3/9KlS6YvyAJtKO0S7NzAF94uDjJXY0JntwDLRkrBqlF/YPBPgJ0V/7xERGRxzCJc0f0RQmCd7ixBK261iv8TWD5Sul5go/7AEwukcVZERERmRPYZ2un+xSVm41xSDhxUSjzU9O5nWVqs3FRg5VNSsGr8CIMVERGZLbZcWYENR6Uuwe4RfvBwstLA4eIDPDoXOPWb9D+DFRERmSmGKwsnhLDuswQ1xbeCVJNHpH9ERERmjN2CFu749UxcTs2Do70SvRv5y12OcZ3ZCHzzAJBxRe5KiIiIqozhysKVXe6md+MAuKitqCHy9HpgxWgg9Rzwz3dyV0NERFRlDFcWTKsVuikYrOpagqfWSYPXtSVA8yeAqHflroiIiKjKGK4s2MEr6biZWQBXtR16RPjJXY5xnPrttmA1BBg0F1BZUYscERFZPYYrC7ahtEvwoaYBcLRXyVyNEZxcA6wcAwgN0GJY6VmBDFZERGRZGK4sVIlGi43HS7sEreEsQU0JsPNTKVhFDgcGfQMorSAwEhGRzWGzgIX652IaUnKK4Olsjy4NfOUu5/6p7IAn1wD/zgO6v8lgRUREFostVxaq7CzBPs0CYa+y4F9j+qVbt139gJ5vMVgREZFFs+BvZdtVVKLF7ycSAFj4WYLHVgJftgEOLZa7EiIiIqNhuLJAu84lIzO/GL6uanSo5yN3OdVzdDmw5lnprMBr++WuhoiIyGgYrizQ+tJrCfZvEQSVUiFzNdVwdBmw9jlAaIHWo4H+n8tdERERkdEwXFmYgmINtpxKBAAMiAySuZpqOLIUWFMarNo8JQUrJV+GRERkPfitZmFi45KQU1iCYE8ntArxkrscwxxeAqx9AYAA2j4N9PuMwYqIiKwOp2KwMGVdgv1aBEFpaV2CaechBatngH6fAgoLq5+IiKgKGK4sSE5hCbadKe0StMSzBHtNBYLbAhF9GKyIiMhqsU/Ggmw7nYiCYi1CfZzRLNhd7nKqJv4PoDhfuq1QAI36MlgREZFVY7iyIGUThw6IrAWFJQSUAz8BS4cAvwwHSgrlroaIiKhGMFxZiMy8YmyPTwZgIdcSPDAf2PCKdNu/MaBykLUcIiKimsJwZSH+OJWAYo1ARIAbwgPc5C7n7v79AdjwqnT7gXFA9IfsCiQiIpvBcGUhyroE+7cw87mt9s8DNr4m3e44Hoj+gMGKiIhsCsOVBUjJKcSe86kAgP7m3CV44Cdg00TpdqcXgYfeZ7AiIiKbw6kYLMDvJxKg0Qo0D/ZAmK+L3OVULqgFoPYA2j4FRL3LYEVERDaJ4coC3DpL0My7BIPbAM/vBjxqM1gREZHNYregmUvILMC/l9IAAP3MceLQ/fOAawdv3fcMYbAiIiKbxnBl5jYevwkhgLZ1vRDs6SR3Ofr2fCWNsVr8KJB5Xe5qiIiIzALDlZm7feJQs7LnS+DPKdLtDv8F3M2sPiIiIplwzJUZu5qWhyNXM6BUAH2aB8pdzi27Pwe2TJNud58E9Jwsbz1ERERmhOHKjK0/JrVaPVDPB/5ujjJXU2rXZ8DWd6TbPSYDPSbJWg4REZG5YbgyY+uP3gRgRl2CJ369LVi9BfR4U9ZyiIiIzBHDlZk6l5SD0zezYKdU4OGmZtIlGNEXqNcTqNsZ6P663NUQERGZJYYrM7WhtEuwa0NfeLnIfNFjIaTpFeydgJGrABVfNkRERJXh2YJmSAhhPmcJxn4kdQUKId1nsCIiIrorflOaodM3s3E+ORcOdko82CRAvkJiZwKxM6TbDR8EQrvIVwsREZGFYLgyQ2VnCfaM8IObo708Rfw9A9g+U7od9S6DFRERURUxXJkZ2bsEhZBaq7Z/JN1/8D2g80s1XwcREZGFYrgyM0euZuBaej6cHVTo1ci/Zp9cCODvD4Ads6T7D30AdBpfszUQERFZOIYrM1M2t1VU4wA4O9Twr+fmUWDHJ9Lt6A+BjuNq9vmJiIisAMOVGdFqBTYel7FLsFZL4JEvgaIc4IHna/75iYiIrADDlRn591IaErMK4eZoh27hvjXzpEJIYUrtJt1vPapmnpeIiMhKcZ4rM1J2lmB000Co7VSmf0IhpAsw/xAF5CSb/vmIiIhsAMOVmSjRaLHpeAKAGuoSFAL4821gzxdA8hngwt+mf04iIiIbwHBlJvacT0VabhG8XRzQqb6PaZ+sLFjt/Uq63/cToMUQ0z4nERGRjeCYKzNRNrdVn2aBsFeZMPMKAfzxFrDvG+l+v0+Bdv8x3fMRERHZGIYrM1BYosEfJ2ugS1AIYPNk4J9vpfv9PwPaPm265yMiIrJBDFdmYGd8CrIKShDgrka7UG/TPVF+OhC3Sbrdfw7QdozpnouIiMhGMVyZgbKzBPs2D4JKqTDdEzl7A09tAK7s4xgrIiIiE2G4kll+kQZbTiUCMFGXoBDSzOu1Wkr3PetI/4iIiMgkeLagzP46k4S8Ig2CPZ3QKsTTuDvXaoGNrwE/9AZOrTPuvomIiKhCbLmSWdlZggMia0GhMGKXoFYLbHoNODAfgAIozDbevomIiKhSDFcyyi4oxl9xSQCAAZFBxtuxVgtsfBU4uACAAhj0LdByuPH2T0RERJViuJLR1tOJKCrRop6fC5oEuRtnp1otsOEV4NBCAArg0blA5DDj7JuIiIjuieFKRuuP3gQA9G9hpC5BrRbY8DJwaBGgUAKD5gKRQ+9/v0RERFRlDFcyycgrwo546WLJA1oYsUsQCilYPfo90OIJI+6XiIiIqoLhSiabTySgRCvQKNANDQPcjLNTpVKaHLT1aKB2W+Psk4iIiAzCqRhkUjZx6H3PbaXVAPvnAZpi6b5SyWBFREQkI4YrGSRlF2Dv+VQAwIAW9xGutBpg7QvAponAmueMVB0RERHdD3YLyuD34wnQCiAyxBN1fJyrtxOtBlj7PHBsOaBQAY0HGLdIIiIiqhaGKxlsKOsSrO5Adk0JsPY54PhKQGkHDJ4PNBloxAqJiIiouhiuatiNjHz8eykdANCvOuFKUwKs+S9wYpUUrJ5YwFYrIiIiM8JwVcM2HpPmtmof6o0gDyfDd7Dh5duC1UKgcX8jV0hERET3gwPaa9itswSr2SXYfAig9gCGLGKwIiIiMkNsuapBl1JycexaJpQKoE/zaoaret2BV44BTp5GrY2IiIiMgy1XNahsIHvnBr7wdVVX7UGaYmD9K0DSmVvLGKyIiIjMFsNVDdpQOt6qynNblRQBK58CDv4ELBkMlBSarjgiIiIyCoarGhKfmI0zCdmwVykQ3TTw3g8oKQJWjQHObABUDkC/2YBdFVu7iIiISDYcc1VDNhyVugS7NfSDh7P93Tcua7GK2wio1MCwpUDDKNMXSURERPeN4aoGCCGwvqxL8F7XEiwpBFbEAPG/S8Fq+FKgAYMVERGRpWC4qgEnb2ThYkou1HZKRDUJuPvGsTOlYGXnKLVYNehdM0USERGRUTBc1YD1pV2CvRv7w1V9j0Pe5RXg2r9A19eA+j1NXxwREREZFcOViQkh7n2WoFYDKFXSbUcPIGY9oFDUUIVERERkTDxb0MQOXcnA9Yx8uDio0LORf/kNiguApUOB3V/cWsZgRUREZLEYrkysrEvwwSYBcLRX6a8sLgCWjwTObQFiZwCZ12WokIiIiIyJ3YImpNEKbDxeyVmCxfnAshHA+b8Ae2dgxArAI1iGKomIiMiYGK5M6J+LqUjOLoS7ox26NvS7taI4H/hlOHDhbylYjVwJhHaRr1AiIiIyGoYrE1p/VGq16tMsCA52pT2wRXnAsuHAhVjA3qU0WHWWr0giIiIyKoYrEynWaPH7iQq6BM/+cStYPbkKqNtJngKJiIjIJBiuTGTfhVRk5BXD19UBD9TzvrWi6aNA1k2gViugbkf5CiQiIiKTYLgykU3HEwBIXYJ2mnyguESawwoAOr4gY2VERERkSpyKwUS2nU4EAAxs4gksGQIsfhQoyJS3KCIiIjI5hisTySksQZibQJtdY4HLu4CUs0DaRbnLIiIiIhMzi3D19ddfIzQ0FI6OjujQoQP2799/1+1XrlyJRo0awdHREc2bN8emTZtqqNKqc0IhFqpnQXFlD6B2B0atAWq1lLssIiIiMjHZw9Xy5csxYcIETJ8+HYcOHUJkZCSio6ORlJRU4fZ79uzB8OHD8cwzz+Dw4cMYNGgQBg0ahBMnTtRw5Xf3vcNs1Mk5Aqg9gFFrgdpt5S6JiIiIaoBCCCHkLKBDhw5o164dvvrqKwCAVqtFSEgIXnzxRUyaNKnc9kOHDkVubi42bNigW/bAAw+gZcuWmDt37j2fLysrCx4eHsjMzIS7u7vxfhAAJSUl2Lx5MwDg4UNPQ2WvhmL0WiC4jVGfh4iIiGpeVTOErC1XRUVFOHjwIKKionTLlEoloqKisHfv3gofs3fvXr3tASA6OrrS7QsLC5GVlaX3ryYUqlyhGP0bgxUREZGNkTVcpaSkQKPRICAgQG95QEAAEhISKnxMQkKCQdvPmDEDHh4eun8hISHGKb4CtzcCJvRbCAS3NtlzERERkXmy+nmuJk+ejAkTJujuZ2VlmSxg2dnZ4eGHH0ZOYTHcndQmeQ4iIiIyb7KGK19fX6hUKiQmJuotT0xMRGBgYIWPCQwMNGh7tVoNtbpmgo5CoYCdnR087aw+sxIREVElZO0WdHBwQJs2bbBt2zbdMq1Wi23btqFjx4ovDdOxY0e97QFgy5YtlW5PREREVJNkb2KZMGECYmJi0LZtW7Rv3x5z5sxBbm4uxowZAwAYPXo0goODMWPGDADAyy+/jO7du+PTTz9Fv379sGzZMhw4cADff/+9nD8GEREREQAzCFdDhw5FcnIypk2bhoSEBLRs2RKbN2/WDVq/cuUKlMpbDWydOnXC0qVL8fbbb+Ott95Cw4YNsXbtWjRr1kyuH4GIiIhIR/Z5rmqaKee5IiIiIutlEfNcEREREVkbhisiIiIiI2K4IiIiIjIihisiIiIiI2K4IiIiIjIihisiIiIiI2K4IiIiIjIihisiIiIiI2K4IiIiIjIihisiIiIiI2K4IiIiIjIihisiIiIiI2K4IiIiIjIihisiIiIiI2K4IiIiIjIihisiIiIiI7KTu4CaJoQAAGRlZclcCREREVmSsuxQliUqY3PhKjs7GwAQEhIicyVERERkibKzs+Hh4VHpeoW4V/yyMlqtFjdu3ICbmxsUCoXR95+VlYWQkBBcvXoV7u7uRt8/3R2Pv7x4/OXH34G8ePzlZerjL4RAdnY2atWqBaWy8pFVNtdypVQqUbt2bZM/j7u7O99YMuLxlxePv/z4O5AXj7+8THn879ZiVYYD2omIiIiMiOGKiIiIyIgYroxMrVZj+vTpUKvVcpdik3j85cXjLz/+DuTF4y8vczn+NjegnYiIiMiU2HJFREREZEQMV0RERERGxHBFREREZEQMV0RERERGxHBVDV9//TVCQ0Ph6OiIDh06YP/+/XfdfuXKlWjUqBEcHR3RvHlzbNq0qYYqtU6GHP958+aha9eu8PLygpeXF6Kiou75+6K7M/T1X2bZsmVQKBQYNGiQaQu0coYe/4yMDIwbNw5BQUFQq9UIDw/nZ9B9MPT4z5kzBxEREXByckJISAheffVVFBQU1FC11mXHjh0YMGAAatWqBYVCgbVr197zMbGxsWjdujXUajUaNGiABQsWmLxOAIAggyxbtkw4ODiI+fPni5MnT4qxY8cKT09PkZiYWOH2u3fvFiqVSnz88cfi1KlT4u233xb29vbi+PHjNVy5dTD0+I8YMUJ8/fXX4vDhw+L06dPiqaeeEh4eHuLatWs1XLl1MPT4l7l48aIIDg4WXbt2FQMHDqyZYq2Qoce/sLBQtG3bVvTt21fs2rVLXLx4UcTGxoojR47UcOXWwdDjv2TJEqFWq8WSJUvExYsXxR9//CGCgoLEq6++WsOVW4dNmzaJKVOmiNWrVwsAYs2aNXfd/sKFC8LZ2VlMmDBBnDp1Snz55ZdCpVKJzZs3m7xWhisDtW/fXowbN053X6PRiFq1aokZM2ZUuP2QIUNEv3799JZ16NBB/Pe//zVpndbK0ON/p5KSEuHm5iYWLlxoqhKtWnWOf0lJiejUqZP44YcfRExMDMPVfTD0+H/77beiXr16oqioqKZKtGqGHv9x48aJXr166S2bMGGC6Ny5s0nrtAVVCVdvvPGGaNq0qd6yoUOHiujoaBNWJmG3oAGKiopw8OBBREVF6ZYplUpERUVh7969FT5m7969etsDQHR0dKXbU+Wqc/zvlJeXh+LiYnh7e5uqTKtV3eP/v//9D/7+/njmmWdqokyrVZ3jv27dOnTs2BHjxo1DQEAAmjVrhg8//BAajaamyrYa1Tn+nTp1wsGDB3VdhxcuXMCmTZvQt2/fGqnZ1sn5/WtzF26+HykpKdBoNAgICNBbHhAQgDNnzlT4mISEhAq3T0hIMFmd1qo6x/9Ob775JmrVqlXuDUf3Vp3jv2vXLvz44484cuRIDVRo3apz/C9cuIC//voLI0eOxKZNm3Du3Dm88MILKC4uxvTp02uibKtRneM/YsQIpKSkoEuXLhBCoKSkBM899xzeeuutmijZ5lX2/ZuVlYX8/Hw4OTmZ7LnZckU2Y+bMmVi2bBnWrFkDR0dHucuxetnZ2Rg1ahTmzZsHX19fucuxSVqtFv7+/vj+++/Rpk0bDB06FFOmTMHcuXPlLs0mxMbG4sMPP8Q333yDQ4cOYfXq1di4cSPee+89uUsjE2PLlQF8fX2hUqmQmJiotzwxMRGBgYEVPiYwMNCg7aly1Tn+ZT755BPMnDkTW7duRYsWLUxZptUy9PifP38ely5dwoABA3TLtFotAMDOzg5xcXGoX7++aYu2ItV5/QcFBcHe3h4qlUq3rHHjxkhISEBRUREcHBxMWrM1qc7xnzp1KkaNGoX//Oc/AIDmzZsjNzcXzz77LKZMmQKlku0bplTZ96+7u7tJW60AtlwZxMHBAW3atMG2bdt0y7RaLbZt24aOHTtW+JiOHTvqbQ8AW7ZsqXR7qlx1jj8AfPzxx3jvvfewefNmtG3btiZKtUqGHv9GjRrh+PHjOHLkiO7fI488gp49e+LIkSMICQmpyfItXnVe/507d8a5c+d0oRYA4uPjERQUxGBloOoc/7y8vHIBqizoCl7W1+Rk/f41+ZB5K7Ns2TKhVqvFggULxKlTp8Szzz4rPD09RUJCghBCiFGjRolJ/2/n7mOiruM4gL/v0HvouIORMTg5H8BgzaV0Jk2skU9xLuvyCS2WIKQNOnE1LdbMOyrUllxDZyU1QYnx5CpcDCgWbMe5EpWHTfAQBKl5yxUOpDiBu09/NH7z5EDJG6j7vLbfH7/v0+/z/cLYZ9/fl196utDearXStGnT6ODBg9Ta2kpGo5E/xXAPJrr+Bw4cIIlEQidPniS73S5cN27cmKopPNAmuv634/8WvDcTXf/u7m5SKpVkMBjIZrPRDz/8QIGBgfTxxx9P1RQeaBNdf6PRSEqlkgoLC+ny5cv0448/UlhYGMXFxU3VFB5oN27coIaGBmpoaCAAZDabqaGhga5cuUJEROnp6fT6668L7Uc+xbB7925qbW2lI0eO8KcY7meHDx+mWbNmkUQioaioKPrll1+EupiYGEpISHBrX1JSQuHh4SSRSGj+/PlUXl4+yRE/XCay/rNnzyYAoy6j0Tj5gT8kJvr7fytOru7dRNf/9OnT9Mwzz5BUKqXQ0FDKzMyk4eHhSY764TGR9R8aGiKTyURhYWEkk8lIo9FQamoqXb9+ffIDfwjU1NR4/Hs+suYJCQkUExMzqk9kZCRJJBIKDQ2l3NzcSYlVRMR7k4wxxhhj3sJnrhhjjDHGvIiTK8YYY4wxL+LkijHGGGPMizi5YowxxhjzIk6uGGOMMca8iJMrxhhjjDEv4uSKMcYYY8yLOLlijDHGGPMiTq4YY16Vl5cHf3//qQ7jfxOJRPj+++/HbZOYmIhXXnllUuJhjD14OLlijI2SmJgIkUg06mpvb5/q0JCXlyfEIxaLERISgq1bt+LatWteGd9ut2P16tUAgK6uLohEIjQ2Nrq1yc7ORl5enleeNxaTySTM08fHBxqNBtu3b0dPT8+ExuFEkLHJN22qA2CM3Z90Oh1yc3Pdyh577LEpisadSqWCzWaDy+VCU1MTtm7diqtXr6Kqquqexw4KCrpjGz8/v3t+zt2YP38+qqur4XQ60draiqSkJPT29qK4uHhSns8Y+39454ox5pFUKkVQUJDb5ePjA7PZjCeffBIKhQIajQapqano7+8fc5ympiYsW7YMSqUSKpUKixYtwtmzZ4X6uro6PPfcc5DL5dBoNEhLS8Pff/89bmwikQhBQUFQq9VYvXo10tLSUF1djYGBAbhcLnz44YcICQmBVCpFZGQkKisrhb6Dg4MwGAwIDg6GTCbD7NmzsX//frexR14Lzp07FwDw1FNPQSQS4fnnnwfgvhuUk5MDtVoNl8vlFqNer0dSUpJwX1ZWBq1WC5lMhtDQUGRkZGB4eHjceU6bNg1BQUGYOXMmVq5ciY0bN+Knn34S6p1OJ5KTkzF37lzI5XJEREQgOztbqDeZTDh+/DjKysqEXbDa2loAwG+//Ya4uDj4+/sjICAAer0eXV1d48bDGLs7nFwxxiZELBbj0KFDuHDhAo4fP46ff/4Z77777pjt4+PjERISgvr6epw7dw7p6emYPn06AKCjowM6nQ7r169Hc3MziouLUVdXB4PBMKGY5HI5XC4XhoeHkZ2djaysLBw8eBDNzc2IjY3Fyy+/jEuXLgEADh06hFOnTqGkpAQ2mw0FBQWYM2eOx3HPnDkDAKiurobdbse33347qs3GjRvx119/oaamRijr6elBZWUl4uPjAQAWiwVbtmzBzp070dLSgqNHjyIvLw+ZmZl3Pceuri5UVVVBIpEIZS6XCyEhISgtLUVLSwv27t2L999/HyUlJQCAXbt2IS4uDjqdDna7HXa7HdHR0RgaGkJsbCyUSiUsFgusVit8fX2h0+kwODh41zExxsZAjDF2m4SEBPLx8SGFQiFcGzZs8Ni2tLSUHn30UeE+NzeX/Pz8hHulUkl5eXke+yYnJ9P27dvdyiwWC4nFYhoYGPDY5/bx29raKDw8nJ5++mkiIlKr1ZSZmenWZ/HixZSamkpERDt27KDly5eTy+XyOD4A+u6774iIqLOzkwBQQ0ODW5uEhATS6/XCvV6vp6SkJOH+6NGjpFaryel0EhHRihUraN++fW5j5OfnU3BwsMcYiIiMRiOJxWJSKBQkk8kIAAEgs9k8Zh8iorfeeovWr18/Zqwjz46IiHBbg5s3b5JcLqeqqqpxx2eM3RmfuWKMebRs2TJ88cUXwr1CoQDw3y7O/v37cfHiRfT19WF4eBgOhwP//PMPHnnkkVHjvPPOO3jjjTeQn58vvNoKCwsD8N8rw+bmZhQUFAjtiQgulwudnZ144oknPMbW29sLX19fuFwuOBwOPPvss/j666/R19eHq1evYunSpW7tly5diqamJgD/vdJbtWoVIiIioNPpsGbNGrzwwgv3tFbx8fHYtm0bPv/8c0ilUhQUFGDz5s0Qi8XCPK1Wq9tOldPpHHfdACAiIgKnTp2Cw+HAN998g8bGRuzYscOtzZEjR3Ds2DF0d3djYGAAg4ODiIyMHDfepqYmtLe3Q6lUupU7HA50dHT8jxVgjN2KkyvGmEcKhQLz5s1zK+vq6sKaNWuQkpKCzMxMBAQEoK6uDsnJyRgcHPSYJJhMJrz22msoLy9HRUUFjEYjioqKsHbtWvT39+PNN99EWlraqH6zZs0aMzalUonz589DLBYjODgYcrkcANDX13fHeWm1WnR2dqKiogLV1dWIi4vDypUrcfLkyTv2HctLL70EIkJ5eTkWL14Mi8WCzz77TKjv7+9HRkYG1q1bN6qvTCYbc1yJRCL8DA4cOIAXX3wRGRkZ+OijjwAARUVF2LVrF7KysrBkyRIolUp8+umn+PXXX8eNt7+/H4sWLXJLakfcL/+0wNiDjJMrxthdO3fuHFwuF7KysoRdmZHzPeMJDw9HeHg43n77bbz66qvIzc3F2rVrodVq0dLSMiqJuxOxWOyxj0qlglqthtVqRUxMjFButVoRFRXl1m7Tpk3YtGkTNmzYAJ1Oh56eHgQEBLiNN3K+yel0jhuPTCbDunXrUFBQgPb2dkRERECr1Qr1Wq0WNpttwvO83Z49e7B8+XKkpKQI84yOjkZqaqrQ5vadJ4lEMip+rVaL4uJiBAYGQqVS3VNMjLHR+EA7Y+yuzZs3D0NDQzh8+DAuX76M/Px8fPnll2O2HxgYgMFgQG1tLa5cuQKr1Yr6+nrhdd97772H06dPw2AwoLGxEZcuXUJZWdmED7Tfavfu3fjkk09QXFwMm82G9PR0NDY2YufOnQAAs9mMwsJCXLx4EW1tbSgtLUVQUJDHD58GBgZCLpejsrISf/zxB3p7e8d8bnx8PMrLy3Hs2DHhIPuIvXv34sSJE8jIyMCFCxfQ2tqKoqIi7NmzZ0JzW7JkCRYsWIB9+/YBAB5//HGcPXsWVVVVaGtrwwcffID6+nq3PnPmzEFzczNsNhv+/PNPDA0NIT4+HjNmzIBer4fFYkFnZydqa2uRlpaG33//fUIxMcY8mOpDX4yx+4+nQ9AjzGYzBQcHk1wup9jYWDpx4gQBoOvXrxOR+4Hzmzdv0ubNm0mj0ZBEIiG1Wk0Gg8HtsPqZM2do1apV5OvrSwqFghYsWDDqQPqtbj/Qfjun00kmk4lmzpxJ06dPp4ULF1JFRYVQn5OTQ5GRkaRQKEilUtGKFSvo/PnzQj1uOdBORPTVV1+RRqMhsVhMMTExY66P0+mk4OBgAkAdHR2j4qqsrKTo6GiSy+WkUqkoKiqKcnJyxpyH0WikhQsXjiovLCwkqVRK3d3d5HA4KDExkfz8/Mjf359SUlIoPT3drd+1a9eE9QVANTU1RERkt9tpy5YtNGPGDJJKpRQaGkrbtm2j3t7eMWNijN0dERHR1KZ3jDHGGGMPD34tyBhjjDHmRZxcMcYYY4x5ESdXjDHGGGNexMkVY4wxxpgXcXLFGGOMMeZFnFwxxhhjjHkRJ1eMMcYYY17EyRVjjDHGmBdxcsUYY4wx5kWcXDHGGGOMeREnV4wxxhhjXvQvPufoQYdsQaAAAAAASUVORK5CYII=",
      "text/plain": [
       "<Figure size 1500x1500 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [
       "<style>#sk-container-id-3 {color: black;background-color: white;}#sk-container-id-3 pre{padding: 0;}#sk-container-id-3 div.sk-toggleable {background-color: white;}#sk-container-id-3 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-3 label.sk-toggleable__label-arrow:before {content: \"▸\";float: left;margin-right: 0.25em;color: #696969;}#sk-container-id-3 label.sk-toggleable__label-arrow:hover:before {color: black;}#sk-container-id-3 div.sk-estimator:hover label.sk-toggleable__label-arrow:before {color: black;}#sk-container-id-3 div.sk-toggleable__content {max-height: 0;max-width: 0;overflow: hidden;text-align: left;background-color: #f0f8ff;}#sk-container-id-3 div.sk-toggleable__content pre {margin: 0.2em;color: black;border-radius: 0.25em;background-color: #f0f8ff;}#sk-container-id-3 input.sk-toggleable__control:checked~div.sk-toggleable__content {max-height: 200px;max-width: 100%;overflow: auto;}#sk-container-id-3 input.sk-toggleable__control:checked~label.sk-toggleable__label-arrow:before {content: \"▾\";}#sk-container-id-3 div.sk-estimator input.sk-toggleable__control:checked~label.sk-toggleable__label {background-color: #d4ebff;}#sk-container-id-3 div.sk-label input.sk-toggleable__control:checked~label.sk-toggleable__label {background-color: #d4ebff;}#sk-container-id-3 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-3 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-3 div.sk-estimator:hover {background-color: #d4ebff;}#sk-container-id-3 div.sk-parallel-item::after {content: \"\";width: 100%;border-bottom: 1px solid gray;flex-grow: 1;}#sk-container-id-3 div.sk-label:hover label.sk-toggleable__label {background-color: #d4ebff;}#sk-container-id-3 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-3 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-3 div.sk-item {position: relative;z-index: 1;}#sk-container-id-3 div.sk-parallel {display: flex;align-items: stretch;justify-content: center;background-color: white;position: relative;}#sk-container-id-3 div.sk-item::before, #sk-container-id-3 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-3 div.sk-parallel-item {display: flex;flex-direction: column;z-index: 1;position: relative;background-color: white;}#sk-container-id-3 div.sk-parallel-item:first-child::after {align-self: flex-end;width: 50%;}#sk-container-id-3 div.sk-parallel-item:last-child::after {align-self: flex-start;width: 50%;}#sk-container-id-3 div.sk-parallel-item:only-child::after {width: 0;}#sk-container-id-3 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-3 div.sk-label label {font-family: monospace;font-weight: bold;display: inline-block;line-height: 1.2em;}#sk-container-id-3 div.sk-label-container {text-align: center;}#sk-container-id-3 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-3 div.sk-text-repr-fallback {display: none;}</style><div id=\"sk-container-id-3\" class=\"sk-top-container\"><div class=\"sk-text-repr-fallback\"><pre>GridSearchCV(cv=2, estimator=SVC(random_state=42), n_jobs=12,\n",
       "             param_grid={&#x27;class_weight&#x27;: [{0: 1, 1: 1}, {0: 1, 1: 4},\n",
       "                                          {0: 0.5468029990852277,\n",
       "                                           1: 5.841538040003653}],\n",
       "                         &#x27;kernel&#x27;: [&#x27;linear&#x27;, &#x27;poly&#x27;, &#x27;rbf&#x27;, &#x27;sigmoid&#x27;]},\n",
       "             return_train_score=True, scoring=make_scorer(fbeta_score, beta=2),\n",
       "             verbose=3)</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 sk-dashed-wrapped\"><div class=\"sk-label-container\"><div class=\"sk-label sk-toggleable\"><input class=\"sk-toggleable__control sk-hidden--visually\" id=\"sk-estimator-id-7\" type=\"checkbox\" ><label for=\"sk-estimator-id-7\" class=\"sk-toggleable__label sk-toggleable__label-arrow\">GridSearchCV</label><div class=\"sk-toggleable__content\"><pre>GridSearchCV(cv=2, estimator=SVC(random_state=42), n_jobs=12,\n",
       "             param_grid={&#x27;class_weight&#x27;: [{0: 1, 1: 1}, {0: 1, 1: 4},\n",
       "                                          {0: 0.5468029990852277,\n",
       "                                           1: 5.841538040003653}],\n",
       "                         &#x27;kernel&#x27;: [&#x27;linear&#x27;, &#x27;poly&#x27;, &#x27;rbf&#x27;, &#x27;sigmoid&#x27;]},\n",
       "             return_train_score=True, scoring=make_scorer(fbeta_score, beta=2),\n",
       "             verbose=3)</pre></div></div></div><div class=\"sk-parallel\"><div class=\"sk-parallel-item\"><div class=\"sk-item\"><div class=\"sk-label-container\"><div class=\"sk-label sk-toggleable\"><input class=\"sk-toggleable__control sk-hidden--visually\" id=\"sk-estimator-id-8\" type=\"checkbox\" ><label for=\"sk-estimator-id-8\" class=\"sk-toggleable__label sk-toggleable__label-arrow\">estimator: SVC</label><div class=\"sk-toggleable__content\"><pre>SVC(random_state=42)</pre></div></div></div><div class=\"sk-serial\"><div class=\"sk-item\"><div class=\"sk-estimator sk-toggleable\"><input class=\"sk-toggleable__control sk-hidden--visually\" id=\"sk-estimator-id-9\" type=\"checkbox\" ><label for=\"sk-estimator-id-9\" class=\"sk-toggleable__label sk-toggleable__label-arrow\">SVC</label><div class=\"sk-toggleable__content\"><pre>SVC(random_state=42)</pre></div></div></div></div></div></div></div></div></div></div>"
      ],
      "text/plain": [
       "GridSearchCV(cv=2, estimator=SVC(random_state=42), n_jobs=12,\n",
       "             param_grid={'class_weight': [{0: 1, 1: 1}, {0: 1, 1: 4},\n",
       "                                          {0: 0.5468029990852277,\n",
       "                                           1: 5.841538040003653}],\n",
       "                         'kernel': ['linear', 'poly', 'rbf', 'sigmoid']},\n",
       "             return_train_score=True, scoring=make_scorer(fbeta_score, beta=2),\n",
       "             verbose=3)"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# svc estimator\n",
    "estimator = Estimator.svc_estimator\n",
    "model_evaluate(estimator, param_grids.get(estimator), **data_dict)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Keras plain model\n",
    "Train keras model with the identified parameters, to take a closer look at the loss and learning curve."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 1/300\n",
      "400/400 [==============================] - 1s 2ms/step - loss: 0.6391 - recall: 0.7611 - val_loss: 0.6200 - val_recall: 0.7502\n",
      "Epoch 2/300\n",
      "400/400 [==============================] - 1s 2ms/step - loss: 0.5893 - recall: 0.7152 - val_loss: 0.5871 - val_recall: 0.7428\n",
      "Epoch 3/300\n",
      "400/400 [==============================] - 1s 2ms/step - loss: 0.5683 - recall: 0.7267 - val_loss: 0.5644 - val_recall: 0.7439\n",
      "Epoch 4/300\n",
      "400/400 [==============================] - 1s 2ms/step - loss: 0.5551 - recall: 0.7321 - val_loss: 0.5507 - val_recall: 0.7502\n",
      "Epoch 5/300\n",
      "400/400 [==============================] - 1s 2ms/step - loss: 0.5449 - recall: 0.7420 - val_loss: 0.5459 - val_recall: 0.7638\n",
      "Epoch 6/300\n",
      "400/400 [==============================] - 1s 2ms/step - loss: 0.5375 - recall: 0.7496 - val_loss: 0.5381 - val_recall: 0.7701\n",
      "Epoch 7/300\n",
      "400/400 [==============================] - 1s 2ms/step - loss: 0.5327 - recall: 0.7586 - val_loss: 0.5236 - val_recall: 0.7699\n",
      "Epoch 8/300\n",
      "400/400 [==============================] - 1s 2ms/step - loss: 0.5270 - recall: 0.7645 - val_loss: 0.5265 - val_recall: 0.7812\n",
      "Epoch 9/300\n",
      "400/400 [==============================] - 1s 2ms/step - loss: 0.5233 - recall: 0.7706 - val_loss: 0.5186 - val_recall: 0.7812\n",
      "Epoch 10/300\n",
      "400/400 [==============================] - 1s 2ms/step - loss: 0.5193 - recall: 0.7716 - val_loss: 0.5176 - val_recall: 0.7898\n",
      "Epoch 11/300\n",
      "400/400 [==============================] - 1s 2ms/step - loss: 0.5176 - recall: 0.7768 - val_loss: 0.5116 - val_recall: 0.7921\n",
      "Epoch 12/300\n",
      "400/400 [==============================] - 1s 2ms/step - loss: 0.5149 - recall: 0.7831 - val_loss: 0.5054 - val_recall: 0.7930\n",
      "Epoch 13/300\n",
      "400/400 [==============================] - 1s 2ms/step - loss: 0.5130 - recall: 0.7843 - val_loss: 0.5065 - val_recall: 0.7972\n",
      "Epoch 14/300\n",
      "400/400 [==============================] - 1s 2ms/step - loss: 0.5119 - recall: 0.7878 - val_loss: 0.5051 - val_recall: 0.8002\n",
      "Epoch 15/300\n",
      "400/400 [==============================] - 1s 2ms/step - loss: 0.5107 - recall: 0.7898 - val_loss: 0.5058 - val_recall: 0.8053\n",
      "Epoch 16/300\n",
      "400/400 [==============================] - 1s 2ms/step - loss: 0.5095 - recall: 0.7889 - val_loss: 0.5078 - val_recall: 0.8106\n",
      "Epoch 17/300\n",
      "400/400 [==============================] - 1s 2ms/step - loss: 0.5096 - recall: 0.7929 - val_loss: 0.5024 - val_recall: 0.8053\n",
      "Epoch 18/300\n",
      "400/400 [==============================] - 1s 2ms/step - loss: 0.5072 - recall: 0.7920 - val_loss: 0.5159 - val_recall: 0.8206\n",
      "Epoch 19/300\n",
      "400/400 [==============================] - 1s 2ms/step - loss: 0.5067 - recall: 0.7965 - val_loss: 0.5064 - val_recall: 0.8143\n",
      "Epoch 20/300\n",
      "400/400 [==============================] - 1s 2ms/step - loss: 0.5069 - recall: 0.7949 - val_loss: 0.5044 - val_recall: 0.8159\n",
      "Epoch 21/300\n",
      "400/400 [==============================] - 1s 2ms/step - loss: 0.5055 - recall: 0.7981 - val_loss: 0.4993 - val_recall: 0.8122\n",
      "Epoch 22/300\n",
      "400/400 [==============================] - 1s 2ms/step - loss: 0.5044 - recall: 0.7968 - val_loss: 0.5006 - val_recall: 0.8127\n",
      "Epoch 23/300\n",
      "400/400 [==============================] - 1s 2ms/step - loss: 0.5046 - recall: 0.7994 - val_loss: 0.4937 - val_recall: 0.8097\n",
      "Epoch 24/300\n",
      "400/400 [==============================] - 1s 2ms/step - loss: 0.5039 - recall: 0.7977 - val_loss: 0.4971 - val_recall: 0.8122\n",
      "Epoch 25/300\n",
      "400/400 [==============================] - 1s 2ms/step - loss: 0.5044 - recall: 0.8007 - val_loss: 0.5118 - val_recall: 0.8229\n",
      "Epoch 26/300\n",
      "400/400 [==============================] - 1s 2ms/step - loss: 0.5048 - recall: 0.8002 - val_loss: 0.5087 - val_recall: 0.8201\n",
      "Epoch 27/300\n",
      "400/400 [==============================] - 1s 2ms/step - loss: 0.5043 - recall: 0.8013 - val_loss: 0.5018 - val_recall: 0.8148\n",
      "Epoch 28/300\n",
      "400/400 [==============================] - 1s 2ms/step - loss: 0.5028 - recall: 0.8020 - val_loss: 0.4990 - val_recall: 0.8136\n",
      "Epoch 29/300\n",
      "400/400 [==============================] - 1s 2ms/step - loss: 0.5032 - recall: 0.8035 - val_loss: 0.4976 - val_recall: 0.8127\n",
      "Epoch 30/300\n",
      "400/400 [==============================] - 1s 2ms/step - loss: 0.5028 - recall: 0.8029 - val_loss: 0.4980 - val_recall: 0.8122\n",
      "Epoch 31/300\n",
      "400/400 [==============================] - 1s 2ms/step - loss: 0.5027 - recall: 0.8042 - val_loss: 0.5123 - val_recall: 0.8224\n",
      "Epoch 32/300\n",
      "400/400 [==============================] - 1s 2ms/step - loss: 0.5019 - recall: 0.8043 - val_loss: 0.4968 - val_recall: 0.8118\n",
      "Epoch 33/300\n",
      "400/400 [==============================] - 1s 2ms/step - loss: 0.5026 - recall: 0.8008 - val_loss: 0.5055 - val_recall: 0.8180\n",
      "Epoch 34/300\n",
      "400/400 [==============================] - 1s 2ms/step - loss: 0.5030 - recall: 0.8031 - val_loss: 0.5031 - val_recall: 0.8178\n",
      "Epoch 35/300\n",
      "400/400 [==============================] - 1s 2ms/step - loss: 0.5016 - recall: 0.8045 - val_loss: 0.5032 - val_recall: 0.8171\n",
      "Epoch 36/300\n",
      "400/400 [==============================] - 1s 2ms/step - loss: 0.5011 - recall: 0.8053 - val_loss: 0.5067 - val_recall: 0.8203\n",
      "Epoch 37/300\n",
      "400/400 [==============================] - 1s 2ms/step - loss: 0.5016 - recall: 0.8037 - val_loss: 0.4977 - val_recall: 0.8136\n",
      "Epoch 38/300\n",
      "400/400 [==============================] - 1s 2ms/step - loss: 0.5004 - recall: 0.8039 - val_loss: 0.4967 - val_recall: 0.8129\n",
      "Epoch 39/300\n",
      "400/400 [==============================] - 1s 2ms/step - loss: 0.5009 - recall: 0.8027 - val_loss: 0.5064 - val_recall: 0.8201\n",
      "Epoch 40/300\n",
      "400/400 [==============================] - 1s 2ms/step - loss: 0.5016 - recall: 0.8070 - val_loss: 0.5067 - val_recall: 0.8222\n",
      "Epoch 41/300\n",
      "400/400 [==============================] - 1s 2ms/step - loss: 0.5015 - recall: 0.8087 - val_loss: 0.4999 - val_recall: 0.8166\n",
      "Epoch 42/300\n",
      "400/400 [==============================] - 1s 2ms/step - loss: 0.5004 - recall: 0.8072 - val_loss: 0.4934 - val_recall: 0.8134\n",
      "Epoch 43/300\n",
      "400/400 [==============================] - 1s 2ms/step - loss: 0.5002 - recall: 0.8107 - val_loss: 0.4880 - val_recall: 0.8071\n",
      "Epoch 44/300\n",
      "400/400 [==============================] - 1s 2ms/step - loss: 0.5009 - recall: 0.8086 - val_loss: 0.5120 - val_recall: 0.8259\n",
      "Epoch 45/300\n",
      "400/400 [==============================] - 1s 2ms/step - loss: 0.5011 - recall: 0.8082 - val_loss: 0.4954 - val_recall: 0.8141\n",
      "Epoch 46/300\n",
      "400/400 [==============================] - 1s 2ms/step - loss: 0.5011 - recall: 0.8082 - val_loss: 0.4992 - val_recall: 0.8176\n",
      "Epoch 47/300\n",
      "400/400 [==============================] - 1s 2ms/step - loss: 0.5001 - recall: 0.8094 - val_loss: 0.4854 - val_recall: 0.8064\n",
      "Epoch 48/300\n",
      "400/400 [==============================] - 1s 2ms/step - loss: 0.5009 - recall: 0.8080 - val_loss: 0.4939 - val_recall: 0.8132\n",
      "Epoch 49/300\n",
      "400/400 [==============================] - 1s 2ms/step - loss: 0.5003 - recall: 0.8081 - val_loss: 0.4972 - val_recall: 0.8166\n",
      "Epoch 50/300\n",
      "400/400 [==============================] - 1s 2ms/step - loss: 0.5002 - recall: 0.8103 - val_loss: 0.4939 - val_recall: 0.8150\n",
      "Epoch 51/300\n",
      "400/400 [==============================] - 1s 2ms/step - loss: 0.5005 - recall: 0.8105 - val_loss: 0.5016 - val_recall: 0.8224\n",
      "Epoch 52/300\n",
      "400/400 [==============================] - 1s 2ms/step - loss: 0.5004 - recall: 0.8094 - val_loss: 0.5045 - val_recall: 0.8224\n",
      "Epoch 53/300\n",
      "400/400 [==============================] - 1s 2ms/step - loss: 0.4997 - recall: 0.8094 - val_loss: 0.4984 - val_recall: 0.8185\n",
      "Epoch 54/300\n",
      "400/400 [==============================] - 1s 2ms/step - loss: 0.4995 - recall: 0.8084 - val_loss: 0.4896 - val_recall: 0.8108\n",
      "Epoch 55/300\n",
      "400/400 [==============================] - 1s 2ms/step - loss: 0.5000 - recall: 0.8114 - val_loss: 0.4867 - val_recall: 0.8090\n",
      "Epoch 56/300\n",
      "400/400 [==============================] - 1s 2ms/step - loss: 0.4990 - recall: 0.8093 - val_loss: 0.5035 - val_recall: 0.8238\n",
      "Epoch 57/300\n",
      "400/400 [==============================] - 1s 2ms/step - loss: 0.4990 - recall: 0.8101 - val_loss: 0.4937 - val_recall: 0.8157\n",
      "Epoch 58/300\n",
      "400/400 [==============================] - 1s 2ms/step - loss: 0.4987 - recall: 0.8125 - val_loss: 0.4865 - val_recall: 0.8088\n",
      "Epoch 59/300\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "400/400 [==============================] - 1s 2ms/step - loss: 0.4985 - recall: 0.8122 - val_loss: 0.4933 - val_recall: 0.8150\n",
      "Epoch 60/300\n",
      "400/400 [==============================] - 1s 2ms/step - loss: 0.4994 - recall: 0.8136 - val_loss: 0.4951 - val_recall: 0.8178\n",
      "Epoch 61/300\n",
      "400/400 [==============================] - 1s 2ms/step - loss: 0.4994 - recall: 0.8107 - val_loss: 0.4995 - val_recall: 0.8199\n",
      "Epoch 62/300\n",
      "400/400 [==============================] - 1s 2ms/step - loss: 0.4992 - recall: 0.8113 - val_loss: 0.4989 - val_recall: 0.8192\n",
      "Epoch 63/300\n",
      "400/400 [==============================] - 1s 2ms/step - loss: 0.4981 - recall: 0.8123 - val_loss: 0.4970 - val_recall: 0.8206\n",
      "Epoch 64/300\n",
      "400/400 [==============================] - 1s 2ms/step - loss: 0.4995 - recall: 0.8126 - val_loss: 0.4976 - val_recall: 0.8206\n",
      "Epoch 65/300\n",
      "400/400 [==============================] - 1s 2ms/step - loss: 0.4992 - recall: 0.8130 - val_loss: 0.4922 - val_recall: 0.8136\n",
      "Epoch 66/300\n",
      "400/400 [==============================] - 1s 2ms/step - loss: 0.4986 - recall: 0.8108 - val_loss: 0.4988 - val_recall: 0.8199\n",
      "Epoch 67/300\n",
      "400/400 [==============================] - 1s 2ms/step - loss: 0.4988 - recall: 0.8131 - val_loss: 0.4956 - val_recall: 0.8185\n",
      "Epoch 68/300\n",
      "400/400 [==============================] - 1s 2ms/step - loss: 0.4989 - recall: 0.8147 - val_loss: 0.4930 - val_recall: 0.8171\n",
      "Epoch 69/300\n",
      "400/400 [==============================] - 1s 2ms/step - loss: 0.4995 - recall: 0.8104 - val_loss: 0.4986 - val_recall: 0.8203\n",
      "Epoch 70/300\n",
      "400/400 [==============================] - 1s 2ms/step - loss: 0.4989 - recall: 0.8140 - val_loss: 0.4964 - val_recall: 0.8178\n",
      "Epoch 71/300\n",
      "400/400 [==============================] - 1s 2ms/step - loss: 0.4995 - recall: 0.8132 - val_loss: 0.5071 - val_recall: 0.8240\n",
      "Epoch 72/300\n",
      "400/400 [==============================] - 1s 2ms/step - loss: 0.4988 - recall: 0.8132 - val_loss: 0.4969 - val_recall: 0.8185\n",
      "Epoch 73/300\n",
      "400/400 [==============================] - 1s 2ms/step - loss: 0.4995 - recall: 0.8126 - val_loss: 0.5017 - val_recall: 0.8226\n",
      "Epoch 74/300\n",
      "400/400 [==============================] - 1s 2ms/step - loss: 0.4985 - recall: 0.8153 - val_loss: 0.4911 - val_recall: 0.8148\n",
      "Epoch 75/300\n",
      "400/400 [==============================] - 1s 2ms/step - loss: 0.4976 - recall: 0.8149 - val_loss: 0.4938 - val_recall: 0.8162\n",
      "Epoch 76/300\n",
      "400/400 [==============================] - 1s 2ms/step - loss: 0.4991 - recall: 0.8143 - val_loss: 0.4897 - val_recall: 0.8125\n",
      "Epoch 77/300\n",
      "400/400 [==============================] - 1s 2ms/step - loss: 0.4979 - recall: 0.8131 - val_loss: 0.4892 - val_recall: 0.8122\n",
      "Epoch 78/300\n",
      "400/400 [==============================] - 1s 2ms/step - loss: 0.4989 - recall: 0.8152 - val_loss: 0.4907 - val_recall: 0.8115\n",
      "Epoch 79/300\n",
      "400/400 [==============================] - 1s 2ms/step - loss: 0.4974 - recall: 0.8119 - val_loss: 0.4896 - val_recall: 0.8136\n",
      "Epoch 80/300\n",
      "400/400 [==============================] - 1s 2ms/step - loss: 0.4982 - recall: 0.8136 - val_loss: 0.4947 - val_recall: 0.8169\n",
      "Epoch 81/300\n",
      "400/400 [==============================] - 1s 2ms/step - loss: 0.4980 - recall: 0.8134 - val_loss: 0.5019 - val_recall: 0.8219\n",
      "Epoch 82/300\n",
      "400/400 [==============================] - 1s 2ms/step - loss: 0.4967 - recall: 0.8141 - val_loss: 0.4980 - val_recall: 0.8194\n",
      "Epoch 83/300\n",
      "400/400 [==============================] - 1s 2ms/step - loss: 0.4986 - recall: 0.8151 - val_loss: 0.4989 - val_recall: 0.8206\n",
      "Epoch 84/300\n",
      "400/400 [==============================] - 1s 2ms/step - loss: 0.4965 - recall: 0.8146 - val_loss: 0.4959 - val_recall: 0.8178\n",
      "Epoch 85/300\n",
      "400/400 [==============================] - 1s 2ms/step - loss: 0.4975 - recall: 0.8155 - val_loss: 0.4869 - val_recall: 0.8097\n",
      "Epoch 86/300\n",
      "400/400 [==============================] - 1s 2ms/step - loss: 0.4976 - recall: 0.8144 - val_loss: 0.4913 - val_recall: 0.8136\n",
      "Epoch 87/300\n",
      "400/400 [==============================] - 1s 2ms/step - loss: 0.4976 - recall: 0.8146 - val_loss: 0.5025 - val_recall: 0.8199\n",
      "Epoch 88/300\n",
      "400/400 [==============================] - 1s 2ms/step - loss: 0.4974 - recall: 0.8143 - val_loss: 0.5026 - val_recall: 0.8231\n",
      "Epoch 89/300\n",
      "400/400 [==============================] - 1s 2ms/step - loss: 0.4980 - recall: 0.8165 - val_loss: 0.4928 - val_recall: 0.8162\n",
      "Epoch 90/300\n",
      "400/400 [==============================] - 1s 2ms/step - loss: 0.4982 - recall: 0.8163 - val_loss: 0.4983 - val_recall: 0.8199\n",
      "Epoch 91/300\n",
      "400/400 [==============================] - 1s 2ms/step - loss: 0.4966 - recall: 0.8170 - val_loss: 0.4912 - val_recall: 0.8145\n",
      "Epoch 92/300\n",
      "400/400 [==============================] - 1s 2ms/step - loss: 0.4977 - recall: 0.8138 - val_loss: 0.5052 - val_recall: 0.8254\n",
      "Epoch 93/300\n",
      "400/400 [==============================] - 1s 2ms/step - loss: 0.4972 - recall: 0.8172 - val_loss: 0.4938 - val_recall: 0.8169\n",
      "Epoch 94/300\n",
      "400/400 [==============================] - 1s 2ms/step - loss: 0.4978 - recall: 0.8145 - val_loss: 0.4965 - val_recall: 0.8185\n",
      "Epoch 95/300\n",
      "400/400 [==============================] - 1s 2ms/step - loss: 0.4973 - recall: 0.8127 - val_loss: 0.4949 - val_recall: 0.8173\n",
      "Epoch 96/300\n",
      "400/400 [==============================] - 1s 2ms/step - loss: 0.4979 - recall: 0.8163 - val_loss: 0.4936 - val_recall: 0.8169\n",
      "Epoch 97/300\n",
      "400/400 [==============================] - 1s 2ms/step - loss: 0.4977 - recall: 0.8136 - val_loss: 0.4913 - val_recall: 0.8134\n",
      "Epoch 98/300\n",
      "400/400 [==============================] - 1s 2ms/step - loss: 0.4973 - recall: 0.8146 - val_loss: 0.4972 - val_recall: 0.8192\n",
      "Epoch 99/300\n",
      "400/400 [==============================] - 1s 2ms/step - loss: 0.4974 - recall: 0.8149 - val_loss: 0.5028 - val_recall: 0.8219\n",
      "Epoch 100/300\n",
      "400/400 [==============================] - 1s 2ms/step - loss: 0.4977 - recall: 0.8153 - val_loss: 0.4928 - val_recall: 0.8145\n",
      "Epoch 101/300\n",
      "400/400 [==============================] - 1s 2ms/step - loss: 0.4959 - recall: 0.8161 - val_loss: 0.4937 - val_recall: 0.8152\n",
      "Epoch 102/300\n",
      "400/400 [==============================] - 1s 2ms/step - loss: 0.4965 - recall: 0.8156 - val_loss: 0.4862 - val_recall: 0.8108\n",
      "Epoch 103/300\n",
      "400/400 [==============================] - 1s 2ms/step - loss: 0.4978 - recall: 0.8172 - val_loss: 0.4949 - val_recall: 0.8164\n",
      "Epoch 104/300\n",
      "400/400 [==============================] - 1s 2ms/step - loss: 0.4970 - recall: 0.8168 - val_loss: 0.4862 - val_recall: 0.8097\n",
      "Epoch 105/300\n",
      "400/400 [==============================] - 1s 2ms/step - loss: 0.4977 - recall: 0.8147 - val_loss: 0.4985 - val_recall: 0.8196\n",
      "Epoch 106/300\n",
      "400/400 [==============================] - 1s 2ms/step - loss: 0.4968 - recall: 0.8172 - val_loss: 0.4952 - val_recall: 0.8166\n",
      "Epoch 107/300\n",
      "400/400 [==============================] - 1s 2ms/step - loss: 0.4972 - recall: 0.8181 - val_loss: 0.5079 - val_recall: 0.8266\n",
      "Epoch 108/300\n",
      "400/400 [==============================] - 1s 2ms/step - loss: 0.4975 - recall: 0.8156 - val_loss: 0.4959 - val_recall: 0.8164\n",
      "Epoch 109/300\n",
      "400/400 [==============================] - 1s 2ms/step - loss: 0.4964 - recall: 0.8146 - val_loss: 0.5052 - val_recall: 0.8229\n",
      "Epoch 110/300\n",
      "400/400 [==============================] - 1s 2ms/step - loss: 0.4979 - recall: 0.8165 - val_loss: 0.5023 - val_recall: 0.8217\n",
      "Epoch 111/300\n",
      "400/400 [==============================] - 1s 2ms/step - loss: 0.4961 - recall: 0.8165 - val_loss: 0.4864 - val_recall: 0.8118\n",
      "Epoch 112/300\n",
      "400/400 [==============================] - 1s 2ms/step - loss: 0.4974 - recall: 0.8149 - val_loss: 0.4898 - val_recall: 0.8136\n",
      "Epoch 113/300\n",
      "400/400 [==============================] - 1s 2ms/step - loss: 0.4972 - recall: 0.8160 - val_loss: 0.4971 - val_recall: 0.8173\n",
      "Epoch 114/300\n",
      "400/400 [==============================] - 1s 2ms/step - loss: 0.4975 - recall: 0.8161 - val_loss: 0.4961 - val_recall: 0.8159\n",
      "Epoch 115/300\n",
      "400/400 [==============================] - 1s 2ms/step - loss: 0.4967 - recall: 0.8157 - val_loss: 0.4968 - val_recall: 0.8180\n",
      "Epoch 116/300\n",
      "400/400 [==============================] - 1s 2ms/step - loss: 0.4964 - recall: 0.8144 - val_loss: 0.5004 - val_recall: 0.8194\n",
      "Epoch 117/300\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "400/400 [==============================] - 1s 2ms/step - loss: 0.4967 - recall: 0.8189 - val_loss: 0.4939 - val_recall: 0.8166\n",
      "Epoch 118/300\n",
      "400/400 [==============================] - 1s 2ms/step - loss: 0.4966 - recall: 0.8164 - val_loss: 0.4977 - val_recall: 0.8185\n",
      "Epoch 119/300\n",
      "400/400 [==============================] - 1s 2ms/step - loss: 0.4963 - recall: 0.8157 - val_loss: 0.5025 - val_recall: 0.8210\n",
      "Epoch 120/300\n",
      "400/400 [==============================] - 1s 2ms/step - loss: 0.4967 - recall: 0.8151 - val_loss: 0.4974 - val_recall: 0.8171\n",
      "Epoch 121/300\n",
      "400/400 [==============================] - 1s 2ms/step - loss: 0.4964 - recall: 0.8163 - val_loss: 0.4989 - val_recall: 0.8187\n",
      "Epoch 122/300\n",
      "400/400 [==============================] - 1s 2ms/step - loss: 0.4966 - recall: 0.8172 - val_loss: 0.4969 - val_recall: 0.8182\n",
      "Epoch 123/300\n",
      "400/400 [==============================] - 1s 2ms/step - loss: 0.4971 - recall: 0.8163 - val_loss: 0.4947 - val_recall: 0.8159\n",
      "Epoch 124/300\n",
      "400/400 [==============================] - 1s 2ms/step - loss: 0.4961 - recall: 0.8159 - val_loss: 0.5026 - val_recall: 0.8222\n",
      "Epoch 125/300\n",
      "400/400 [==============================] - 1s 2ms/step - loss: 0.4970 - recall: 0.8185 - val_loss: 0.4970 - val_recall: 0.8169\n",
      "Epoch 126/300\n",
      "400/400 [==============================] - 1s 2ms/step - loss: 0.4974 - recall: 0.8169 - val_loss: 0.5035 - val_recall: 0.8226\n",
      "Epoch 127/300\n",
      "400/400 [==============================] - 1s 2ms/step - loss: 0.4958 - recall: 0.8157 - val_loss: 0.5026 - val_recall: 0.8219\n",
      "Epoch 128/300\n",
      "400/400 [==============================] - 1s 2ms/step - loss: 0.4973 - recall: 0.8187 - val_loss: 0.4946 - val_recall: 0.8171\n",
      "Epoch 129/300\n",
      "400/400 [==============================] - 1s 2ms/step - loss: 0.4973 - recall: 0.8159 - val_loss: 0.4937 - val_recall: 0.8176\n",
      "Epoch 130/300\n",
      "400/400 [==============================] - 1s 2ms/step - loss: 0.4964 - recall: 0.8172 - val_loss: 0.4954 - val_recall: 0.8166\n",
      "Epoch 131/300\n",
      "400/400 [==============================] - 1s 2ms/step - loss: 0.4962 - recall: 0.8157 - val_loss: 0.4978 - val_recall: 0.8182\n",
      "Epoch 132/300\n",
      "400/400 [==============================] - 1s 2ms/step - loss: 0.4970 - recall: 0.8186 - val_loss: 0.4928 - val_recall: 0.8157\n",
      "Epoch 133/300\n",
      "400/400 [==============================] - 1s 2ms/step - loss: 0.4959 - recall: 0.8159 - val_loss: 0.4947 - val_recall: 0.8173\n",
      "Epoch 134/300\n",
      "400/400 [==============================] - 1s 2ms/step - loss: 0.4963 - recall: 0.8161 - val_loss: 0.4972 - val_recall: 0.8187\n",
      "Epoch 135/300\n",
      "400/400 [==============================] - 1s 2ms/step - loss: 0.4961 - recall: 0.8161 - val_loss: 0.4953 - val_recall: 0.8150\n",
      "Epoch 136/300\n",
      "400/400 [==============================] - 1s 2ms/step - loss: 0.4956 - recall: 0.8162 - val_loss: 0.4989 - val_recall: 0.8201\n",
      "Epoch 137/300\n",
      "400/400 [==============================] - 1s 2ms/step - loss: 0.4953 - recall: 0.8178 - val_loss: 0.4967 - val_recall: 0.8171\n",
      "Epoch 138/300\n",
      "400/400 [==============================] - 1s 2ms/step - loss: 0.4960 - recall: 0.8150 - val_loss: 0.4990 - val_recall: 0.8215\n",
      "Epoch 139/300\n",
      "400/400 [==============================] - 1s 2ms/step - loss: 0.4961 - recall: 0.8182 - val_loss: 0.4926 - val_recall: 0.8155\n",
      "Epoch 140/300\n",
      "400/400 [==============================] - 1s 2ms/step - loss: 0.4958 - recall: 0.8153 - val_loss: 0.4966 - val_recall: 0.8176\n",
      "Epoch 141/300\n",
      "400/400 [==============================] - 1s 2ms/step - loss: 0.4958 - recall: 0.8169 - val_loss: 0.5035 - val_recall: 0.8224\n",
      "Epoch 142/300\n",
      "400/400 [==============================] - 1s 2ms/step - loss: 0.4961 - recall: 0.8175 - val_loss: 0.4992 - val_recall: 0.8187\n",
      "Epoch 143/300\n",
      "400/400 [==============================] - 1s 2ms/step - loss: 0.4955 - recall: 0.8166 - val_loss: 0.5001 - val_recall: 0.8203\n",
      "Epoch 144/300\n",
      "400/400 [==============================] - 1s 2ms/step - loss: 0.4947 - recall: 0.8169 - val_loss: 0.4891 - val_recall: 0.8125\n",
      "Epoch 145/300\n",
      "400/400 [==============================] - 1s 2ms/step - loss: 0.4957 - recall: 0.8176 - val_loss: 0.4956 - val_recall: 0.8178\n",
      "Epoch 146/300\n",
      "400/400 [==============================] - 1s 2ms/step - loss: 0.4968 - recall: 0.8167 - val_loss: 0.4924 - val_recall: 0.8150\n",
      "Epoch 147/300\n",
      "400/400 [==============================] - 1s 2ms/step - loss: 0.4964 - recall: 0.8169 - val_loss: 0.4952 - val_recall: 0.8166\n",
      "Epoch 148/300\n",
      "400/400 [==============================] - 1s 2ms/step - loss: 0.4963 - recall: 0.8159 - val_loss: 0.5009 - val_recall: 0.8206\n",
      "Epoch 149/300\n",
      "400/400 [==============================] - 1s 2ms/step - loss: 0.4959 - recall: 0.8189 - val_loss: 0.4908 - val_recall: 0.8134\n",
      "Epoch 150/300\n",
      "400/400 [==============================] - 1s 2ms/step - loss: 0.4963 - recall: 0.8148 - val_loss: 0.5018 - val_recall: 0.8208\n",
      "Epoch 151/300\n",
      "400/400 [==============================] - 1s 2ms/step - loss: 0.4953 - recall: 0.8165 - val_loss: 0.4955 - val_recall: 0.8162\n",
      "Epoch 152/300\n",
      "400/400 [==============================] - 1s 2ms/step - loss: 0.4968 - recall: 0.8176 - val_loss: 0.4963 - val_recall: 0.8159\n",
      "Epoch 153/300\n",
      "400/400 [==============================] - 1s 2ms/step - loss: 0.4964 - recall: 0.8172 - val_loss: 0.4989 - val_recall: 0.8171\n",
      "Epoch 154/300\n",
      "400/400 [==============================] - 1s 2ms/step - loss: 0.4960 - recall: 0.8139 - val_loss: 0.4967 - val_recall: 0.8176\n",
      "Epoch 155/300\n",
      "400/400 [==============================] - 1s 2ms/step - loss: 0.4960 - recall: 0.8172 - val_loss: 0.5017 - val_recall: 0.8219\n",
      "Epoch 156/300\n",
      "400/400 [==============================] - 1s 2ms/step - loss: 0.4953 - recall: 0.8175 - val_loss: 0.4950 - val_recall: 0.8166\n",
      "Epoch 157/300\n",
      "400/400 [==============================] - 1s 2ms/step - loss: 0.4955 - recall: 0.8177 - val_loss: 0.4904 - val_recall: 0.8129\n",
      "Epoch 158/300\n",
      "400/400 [==============================] - 1s 2ms/step - loss: 0.4946 - recall: 0.8166 - val_loss: 0.4905 - val_recall: 0.8145\n",
      "Epoch 159/300\n",
      "400/400 [==============================] - 1s 2ms/step - loss: 0.4958 - recall: 0.8163 - val_loss: 0.5030 - val_recall: 0.8231\n",
      "Epoch 160/300\n",
      "400/400 [==============================] - 1s 2ms/step - loss: 0.4958 - recall: 0.8186 - val_loss: 0.4947 - val_recall: 0.8166\n",
      "Epoch 161/300\n",
      "400/400 [==============================] - 1s 2ms/step - loss: 0.4954 - recall: 0.8183 - val_loss: 0.4959 - val_recall: 0.8159\n",
      "Epoch 162/300\n",
      "400/400 [==============================] - 1s 2ms/step - loss: 0.4957 - recall: 0.8170 - val_loss: 0.4854 - val_recall: 0.8101\n",
      "Epoch 163/300\n",
      "400/400 [==============================] - 1s 2ms/step - loss: 0.4955 - recall: 0.8177 - val_loss: 0.4920 - val_recall: 0.8150\n",
      "Epoch 164/300\n",
      "400/400 [==============================] - 1s 2ms/step - loss: 0.4952 - recall: 0.8146 - val_loss: 0.4899 - val_recall: 0.8132\n",
      "Epoch 165/300\n",
      "400/400 [==============================] - 1s 2ms/step - loss: 0.4953 - recall: 0.8155 - val_loss: 0.5024 - val_recall: 0.8224\n",
      "Epoch 166/300\n",
      "400/400 [==============================] - 1s 2ms/step - loss: 0.4953 - recall: 0.8177 - val_loss: 0.4884 - val_recall: 0.8113\n",
      "Epoch 167/300\n",
      "400/400 [==============================] - 1s 2ms/step - loss: 0.4948 - recall: 0.8182 - val_loss: 0.4914 - val_recall: 0.8143\n",
      "Epoch 168/300\n",
      "400/400 [==============================] - 1s 2ms/step - loss: 0.4954 - recall: 0.8167 - val_loss: 0.5003 - val_recall: 0.8196\n",
      "Epoch 169/300\n",
      "400/400 [==============================] - 1s 2ms/step - loss: 0.4953 - recall: 0.8184 - val_loss: 0.4873 - val_recall: 0.8106\n",
      "Epoch 170/300\n",
      "400/400 [==============================] - 1s 2ms/step - loss: 0.4956 - recall: 0.8180 - val_loss: 0.4983 - val_recall: 0.8189\n",
      "Epoch 171/300\n",
      "400/400 [==============================] - 1s 2ms/step - loss: 0.4948 - recall: 0.8167 - val_loss: 0.5010 - val_recall: 0.8206\n",
      "Epoch 172/300\n",
      "400/400 [==============================] - 1s 2ms/step - loss: 0.4962 - recall: 0.8169 - val_loss: 0.4992 - val_recall: 0.8185\n",
      "Epoch 173/300\n",
      "400/400 [==============================] - 1s 2ms/step - loss: 0.4950 - recall: 0.8159 - val_loss: 0.4940 - val_recall: 0.8148\n",
      "Epoch 174/300\n",
      "400/400 [==============================] - 1s 2ms/step - loss: 0.4950 - recall: 0.8145 - val_loss: 0.5073 - val_recall: 0.8243\n",
      "Epoch 175/300\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "400/400 [==============================] - 1s 2ms/step - loss: 0.4959 - recall: 0.8183 - val_loss: 0.4898 - val_recall: 0.8129\n",
      "Epoch 176/300\n",
      "400/400 [==============================] - 1s 2ms/step - loss: 0.4947 - recall: 0.8194 - val_loss: 0.4822 - val_recall: 0.8083\n",
      "Epoch 177/300\n",
      "400/400 [==============================] - 1s 2ms/step - loss: 0.4943 - recall: 0.8142 - val_loss: 0.4947 - val_recall: 0.8157\n",
      "Epoch 178/300\n",
      "400/400 [==============================] - 1s 2ms/step - loss: 0.4963 - recall: 0.8167 - val_loss: 0.4968 - val_recall: 0.8166\n",
      "Epoch 179/300\n",
      "400/400 [==============================] - 1s 2ms/step - loss: 0.4951 - recall: 0.8167 - val_loss: 0.4905 - val_recall: 0.8129\n",
      "Epoch 180/300\n",
      "400/400 [==============================] - 1s 2ms/step - loss: 0.4946 - recall: 0.8170 - val_loss: 0.4971 - val_recall: 0.8166\n",
      "Epoch 181/300\n",
      "400/400 [==============================] - 1s 2ms/step - loss: 0.4949 - recall: 0.8166 - val_loss: 0.5055 - val_recall: 0.8226\n",
      "Epoch 182/300\n",
      "400/400 [==============================] - 1s 2ms/step - loss: 0.4951 - recall: 0.8166 - val_loss: 0.5016 - val_recall: 0.8194\n",
      "Epoch 183/300\n",
      "400/400 [==============================] - 1s 2ms/step - loss: 0.4951 - recall: 0.8176 - val_loss: 0.4895 - val_recall: 0.8132\n",
      "Epoch 184/300\n",
      "400/400 [==============================] - 1s 2ms/step - loss: 0.4940 - recall: 0.8169 - val_loss: 0.4902 - val_recall: 0.8125\n",
      "Epoch 185/300\n",
      "400/400 [==============================] - 1s 2ms/step - loss: 0.4949 - recall: 0.8161 - val_loss: 0.4938 - val_recall: 0.8159\n",
      "Epoch 186/300\n",
      "400/400 [==============================] - 1s 2ms/step - loss: 0.4949 - recall: 0.8172 - val_loss: 0.4931 - val_recall: 0.8148\n",
      "Epoch 187/300\n",
      "400/400 [==============================] - 1s 2ms/step - loss: 0.4949 - recall: 0.8179 - val_loss: 0.4981 - val_recall: 0.8178\n",
      "Epoch 188/300\n",
      "400/400 [==============================] - 1s 2ms/step - loss: 0.4951 - recall: 0.8161 - val_loss: 0.4963 - val_recall: 0.8162\n",
      "Epoch 189/300\n",
      "400/400 [==============================] - 1s 2ms/step - loss: 0.4957 - recall: 0.8173 - val_loss: 0.5054 - val_recall: 0.8245\n",
      "Epoch 190/300\n",
      "400/400 [==============================] - 1s 2ms/step - loss: 0.4942 - recall: 0.8177 - val_loss: 0.4885 - val_recall: 0.8120\n",
      "Epoch 191/300\n",
      "400/400 [==============================] - 1s 2ms/step - loss: 0.4941 - recall: 0.8167 - val_loss: 0.4890 - val_recall: 0.8122\n",
      "Epoch 192/300\n",
      "400/400 [==============================] - 1s 2ms/step - loss: 0.4951 - recall: 0.8186 - val_loss: 0.4987 - val_recall: 0.8185\n",
      "Epoch 193/300\n",
      "400/400 [==============================] - 1s 2ms/step - loss: 0.4944 - recall: 0.8171 - val_loss: 0.5014 - val_recall: 0.8208\n",
      "Epoch 194/300\n",
      "400/400 [==============================] - 1s 2ms/step - loss: 0.4952 - recall: 0.8173 - val_loss: 0.4968 - val_recall: 0.8180\n",
      "Epoch 195/300\n",
      "400/400 [==============================] - 1s 2ms/step - loss: 0.4952 - recall: 0.8182 - val_loss: 0.4957 - val_recall: 0.8164\n",
      "Epoch 196/300\n",
      "400/400 [==============================] - 1s 2ms/step - loss: 0.4953 - recall: 0.8173 - val_loss: 0.4968 - val_recall: 0.8166\n",
      "Epoch 197/300\n",
      "400/400 [==============================] - 1s 2ms/step - loss: 0.4945 - recall: 0.8176 - val_loss: 0.4980 - val_recall: 0.8164\n",
      "Epoch 198/300\n",
      "400/400 [==============================] - 1s 2ms/step - loss: 0.4955 - recall: 0.8171 - val_loss: 0.4954 - val_recall: 0.8162\n",
      "Epoch 199/300\n",
      "400/400 [==============================] - 1s 2ms/step - loss: 0.4946 - recall: 0.8160 - val_loss: 0.5003 - val_recall: 0.8194\n",
      "Epoch 200/300\n",
      "400/400 [==============================] - 1s 2ms/step - loss: 0.4939 - recall: 0.8155 - val_loss: 0.4978 - val_recall: 0.8171\n",
      "Epoch 201/300\n",
      "400/400 [==============================] - 1s 2ms/step - loss: 0.4952 - recall: 0.8171 - val_loss: 0.5021 - val_recall: 0.8192\n",
      "Epoch 202/300\n",
      "400/400 [==============================] - 1s 2ms/step - loss: 0.4953 - recall: 0.8155 - val_loss: 0.5034 - val_recall: 0.8224\n",
      "Epoch 203/300\n",
      "400/400 [==============================] - 1s 2ms/step - loss: 0.4946 - recall: 0.8180 - val_loss: 0.4943 - val_recall: 0.8145\n",
      "Epoch 204/300\n",
      "400/400 [==============================] - 1s 2ms/step - loss: 0.4946 - recall: 0.8190 - val_loss: 0.4768 - val_recall: 0.8013\n",
      "Epoch 205/300\n",
      "400/400 [==============================] - 1s 2ms/step - loss: 0.4935 - recall: 0.8165 - val_loss: 0.4884 - val_recall: 0.8097\n",
      "Epoch 206/300\n",
      "400/400 [==============================] - 1s 2ms/step - loss: 0.4947 - recall: 0.8152 - val_loss: 0.5001 - val_recall: 0.8171\n",
      "Epoch 207/300\n",
      "400/400 [==============================] - 1s 2ms/step - loss: 0.4950 - recall: 0.8167 - val_loss: 0.4974 - val_recall: 0.8162\n",
      "Epoch 208/300\n",
      "400/400 [==============================] - 1s 2ms/step - loss: 0.4947 - recall: 0.8184 - val_loss: 0.5025 - val_recall: 0.8206\n",
      "Epoch 209/300\n",
      "400/400 [==============================] - 1s 2ms/step - loss: 0.4944 - recall: 0.8191 - val_loss: 0.4977 - val_recall: 0.8164\n",
      "Epoch 210/300\n",
      "400/400 [==============================] - 1s 2ms/step - loss: 0.4947 - recall: 0.8175 - val_loss: 0.5037 - val_recall: 0.8213\n",
      "Epoch 211/300\n",
      "400/400 [==============================] - 1s 2ms/step - loss: 0.4934 - recall: 0.8192 - val_loss: 0.4914 - val_recall: 0.8136\n",
      "Epoch 212/300\n",
      "400/400 [==============================] - 1s 2ms/step - loss: 0.4943 - recall: 0.8167 - val_loss: 0.5072 - val_recall: 0.8245\n",
      "Epoch 213/300\n",
      "400/400 [==============================] - 1s 2ms/step - loss: 0.4947 - recall: 0.8197 - val_loss: 0.4978 - val_recall: 0.8171\n",
      "Epoch 214/300\n",
      "400/400 [==============================] - 1s 2ms/step - loss: 0.4948 - recall: 0.8171 - val_loss: 0.4915 - val_recall: 0.8129\n",
      "Epoch 215/300\n",
      "400/400 [==============================] - 1s 2ms/step - loss: 0.4946 - recall: 0.8162 - val_loss: 0.4884 - val_recall: 0.8113\n",
      "Epoch 216/300\n",
      "400/400 [==============================] - 1s 2ms/step - loss: 0.4941 - recall: 0.8180 - val_loss: 0.4932 - val_recall: 0.8157\n",
      "Epoch 217/300\n",
      "400/400 [==============================] - 1s 2ms/step - loss: 0.4939 - recall: 0.8196 - val_loss: 0.4952 - val_recall: 0.8152\n",
      "Epoch 218/300\n",
      "400/400 [==============================] - 1s 2ms/step - loss: 0.4940 - recall: 0.8192 - val_loss: 0.4829 - val_recall: 0.8060\n",
      "Epoch 219/300\n",
      "400/400 [==============================] - 1s 2ms/step - loss: 0.4943 - recall: 0.8186 - val_loss: 0.4988 - val_recall: 0.8169\n",
      "Epoch 220/300\n",
      "400/400 [==============================] - 1s 2ms/step - loss: 0.4942 - recall: 0.8175 - val_loss: 0.4970 - val_recall: 0.8166\n",
      "Epoch 221/300\n",
      "400/400 [==============================] - 1s 2ms/step - loss: 0.4947 - recall: 0.8194 - val_loss: 0.4930 - val_recall: 0.8132\n",
      "Epoch 222/300\n",
      "400/400 [==============================] - 1s 2ms/step - loss: 0.4944 - recall: 0.8153 - val_loss: 0.5060 - val_recall: 0.8224\n",
      "Epoch 223/300\n",
      "400/400 [==============================] - 1s 2ms/step - loss: 0.4945 - recall: 0.8176 - val_loss: 0.4990 - val_recall: 0.8194\n",
      "Epoch 224/300\n",
      "400/400 [==============================] - 1s 2ms/step - loss: 0.4947 - recall: 0.8187 - val_loss: 0.4945 - val_recall: 0.8148\n",
      "Epoch 225/300\n",
      "400/400 [==============================] - 1s 2ms/step - loss: 0.4951 - recall: 0.8184 - val_loss: 0.5018 - val_recall: 0.8194\n",
      "Epoch 226/300\n",
      "400/400 [==============================] - 1s 2ms/step - loss: 0.4944 - recall: 0.8194 - val_loss: 0.5006 - val_recall: 0.8176\n",
      "Epoch 227/300\n",
      "400/400 [==============================] - 1s 2ms/step - loss: 0.4937 - recall: 0.8169 - val_loss: 0.4936 - val_recall: 0.8134\n",
      "Epoch 228/300\n",
      "400/400 [==============================] - 1s 2ms/step - loss: 0.4936 - recall: 0.8168 - val_loss: 0.4993 - val_recall: 0.8178\n",
      "Epoch 229/300\n",
      "400/400 [==============================] - 1s 2ms/step - loss: 0.4940 - recall: 0.8157 - val_loss: 0.4910 - val_recall: 0.8120\n",
      "Epoch 230/300\n",
      "400/400 [==============================] - 1s 2ms/step - loss: 0.4947 - recall: 0.8163 - val_loss: 0.5000 - val_recall: 0.8178\n",
      "Epoch 231/300\n",
      "400/400 [==============================] - 1s 2ms/step - loss: 0.4940 - recall: 0.8152 - val_loss: 0.4996 - val_recall: 0.8182\n",
      "Epoch 232/300\n",
      "400/400 [==============================] - 1s 2ms/step - loss: 0.4949 - recall: 0.8164 - val_loss: 0.4957 - val_recall: 0.8148\n",
      "Epoch 233/300\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "400/400 [==============================] - 1s 2ms/step - loss: 0.4945 - recall: 0.8174 - val_loss: 0.4859 - val_recall: 0.8092\n",
      "Epoch 234/300\n",
      "400/400 [==============================] - 1s 2ms/step - loss: 0.4945 - recall: 0.8157 - val_loss: 0.4952 - val_recall: 0.8138\n",
      "Epoch 235/300\n",
      "400/400 [==============================] - 1s 2ms/step - loss: 0.4939 - recall: 0.8168 - val_loss: 0.4925 - val_recall: 0.8118\n",
      "Epoch 236/300\n",
      "400/400 [==============================] - 1s 2ms/step - loss: 0.4932 - recall: 0.8155 - val_loss: 0.5003 - val_recall: 0.8176\n",
      "Epoch 237/300\n",
      "400/400 [==============================] - 1s 2ms/step - loss: 0.4937 - recall: 0.8183 - val_loss: 0.4896 - val_recall: 0.8106\n",
      "Epoch 238/300\n",
      "400/400 [==============================] - 1s 2ms/step - loss: 0.4941 - recall: 0.8193 - val_loss: 0.4989 - val_recall: 0.8159\n",
      "Epoch 239/300\n",
      "400/400 [==============================] - 1s 2ms/step - loss: 0.4936 - recall: 0.8183 - val_loss: 0.4971 - val_recall: 0.8171\n",
      "Epoch 240/300\n",
      "400/400 [==============================] - 1s 2ms/step - loss: 0.4947 - recall: 0.8188 - val_loss: 0.4877 - val_recall: 0.8111\n",
      "Epoch 241/300\n",
      "400/400 [==============================] - 1s 2ms/step - loss: 0.4948 - recall: 0.8176 - val_loss: 0.4918 - val_recall: 0.8122\n",
      "Epoch 242/300\n",
      "400/400 [==============================] - 1s 2ms/step - loss: 0.4949 - recall: 0.8189 - val_loss: 0.4914 - val_recall: 0.8115\n",
      "Epoch 243/300\n",
      "400/400 [==============================] - 1s 2ms/step - loss: 0.4944 - recall: 0.8164 - val_loss: 0.4941 - val_recall: 0.8134\n",
      "Epoch 244/300\n",
      "400/400 [==============================] - 1s 2ms/step - loss: 0.4939 - recall: 0.8169 - val_loss: 0.4962 - val_recall: 0.8152\n",
      "Epoch 245/300\n",
      "400/400 [==============================] - 1s 2ms/step - loss: 0.4950 - recall: 0.8159 - val_loss: 0.4925 - val_recall: 0.8132\n",
      "Epoch 246/300\n",
      "400/400 [==============================] - 1s 2ms/step - loss: 0.4944 - recall: 0.8169 - val_loss: 0.4906 - val_recall: 0.8125\n",
      "Epoch 247/300\n",
      "400/400 [==============================] - 1s 2ms/step - loss: 0.4932 - recall: 0.8190 - val_loss: 0.4902 - val_recall: 0.8106\n",
      "Epoch 248/300\n",
      "400/400 [==============================] - 1s 2ms/step - loss: 0.4939 - recall: 0.8170 - val_loss: 0.4902 - val_recall: 0.8111\n",
      "Epoch 249/300\n",
      "400/400 [==============================] - 1s 2ms/step - loss: 0.4943 - recall: 0.8153 - val_loss: 0.4996 - val_recall: 0.8176\n",
      "Epoch 250/300\n",
      "400/400 [==============================] - 1s 2ms/step - loss: 0.4938 - recall: 0.8189 - val_loss: 0.4913 - val_recall: 0.8120\n",
      "Epoch 251/300\n",
      "400/400 [==============================] - 1s 2ms/step - loss: 0.4936 - recall: 0.8178 - val_loss: 0.4926 - val_recall: 0.8129\n",
      "Epoch 252/300\n",
      "400/400 [==============================] - 1s 2ms/step - loss: 0.4938 - recall: 0.8179 - val_loss: 0.4921 - val_recall: 0.8132\n",
      "Epoch 253/300\n",
      "400/400 [==============================] - 1s 2ms/step - loss: 0.4943 - recall: 0.8171 - val_loss: 0.5044 - val_recall: 0.8219\n",
      "Epoch 254/300\n",
      "400/400 [==============================] - 1s 2ms/step - loss: 0.4940 - recall: 0.8181 - val_loss: 0.5019 - val_recall: 0.8192\n",
      "Epoch 255/300\n",
      "400/400 [==============================] - 1s 2ms/step - loss: 0.4939 - recall: 0.8178 - val_loss: 0.4957 - val_recall: 0.8145\n",
      "Epoch 256/300\n",
      "400/400 [==============================] - 1s 2ms/step - loss: 0.4949 - recall: 0.8180 - val_loss: 0.4979 - val_recall: 0.8185\n",
      "Epoch 257/300\n",
      "400/400 [==============================] - 1s 2ms/step - loss: 0.4944 - recall: 0.8193 - val_loss: 0.5043 - val_recall: 0.8236\n",
      "Epoch 258/300\n",
      "400/400 [==============================] - 1s 2ms/step - loss: 0.4936 - recall: 0.8189 - val_loss: 0.5050 - val_recall: 0.8236\n",
      "Epoch 259/300\n",
      "400/400 [==============================] - 1s 2ms/step - loss: 0.4940 - recall: 0.8201 - val_loss: 0.4865 - val_recall: 0.8097\n",
      "Epoch 260/300\n",
      "400/400 [==============================] - 1s 2ms/step - loss: 0.4941 - recall: 0.8174 - val_loss: 0.4926 - val_recall: 0.8125\n",
      "Epoch 261/300\n",
      "400/400 [==============================] - 1s 2ms/step - loss: 0.4946 - recall: 0.8193 - val_loss: 0.4932 - val_recall: 0.8125\n",
      "Epoch 262/300\n",
      "400/400 [==============================] - 1s 2ms/step - loss: 0.4943 - recall: 0.8180 - val_loss: 0.4981 - val_recall: 0.8166\n",
      "Epoch 263/300\n",
      "400/400 [==============================] - 1s 2ms/step - loss: 0.4929 - recall: 0.8186 - val_loss: 0.4998 - val_recall: 0.8194\n",
      "Epoch 264/300\n",
      "400/400 [==============================] - 1s 2ms/step - loss: 0.4936 - recall: 0.8190 - val_loss: 0.4981 - val_recall: 0.8187\n",
      "Epoch 265/300\n",
      "400/400 [==============================] - 1s 2ms/step - loss: 0.4932 - recall: 0.8206 - val_loss: 0.4934 - val_recall: 0.8134\n",
      "Epoch 266/300\n",
      "400/400 [==============================] - 1s 2ms/step - loss: 0.4938 - recall: 0.8182 - val_loss: 0.4860 - val_recall: 0.8092\n",
      "Epoch 267/300\n",
      "400/400 [==============================] - 1s 2ms/step - loss: 0.4944 - recall: 0.8176 - val_loss: 0.4983 - val_recall: 0.8176\n",
      "Epoch 268/300\n",
      "400/400 [==============================] - 1s 2ms/step - loss: 0.4923 - recall: 0.8197 - val_loss: 0.4922 - val_recall: 0.8145\n",
      "Epoch 269/300\n",
      "400/400 [==============================] - 1s 2ms/step - loss: 0.4942 - recall: 0.8182 - val_loss: 0.4965 - val_recall: 0.8173\n",
      "Epoch 270/300\n",
      "400/400 [==============================] - 1s 2ms/step - loss: 0.4934 - recall: 0.8173 - val_loss: 0.4908 - val_recall: 0.8122\n",
      "Epoch 271/300\n",
      "400/400 [==============================] - 1s 2ms/step - loss: 0.4937 - recall: 0.8165 - val_loss: 0.4970 - val_recall: 0.8176\n",
      "Epoch 272/300\n",
      "400/400 [==============================] - 1s 2ms/step - loss: 0.4937 - recall: 0.8190 - val_loss: 0.4922 - val_recall: 0.8122\n",
      "Epoch 273/300\n",
      "400/400 [==============================] - 1s 2ms/step - loss: 0.4934 - recall: 0.8197 - val_loss: 0.5031 - val_recall: 0.8206\n",
      "Epoch 274/300\n",
      "400/400 [==============================] - 1s 2ms/step - loss: 0.4944 - recall: 0.8190 - val_loss: 0.4993 - val_recall: 0.8176\n",
      "Epoch 275/300\n",
      "400/400 [==============================] - 1s 2ms/step - loss: 0.4932 - recall: 0.8176 - val_loss: 0.4962 - val_recall: 0.8152\n",
      "Epoch 276/300\n",
      "400/400 [==============================] - 1s 2ms/step - loss: 0.4950 - recall: 0.8195 - val_loss: 0.4989 - val_recall: 0.8182\n",
      "Epoch 277/300\n",
      "400/400 [==============================] - 1s 2ms/step - loss: 0.4928 - recall: 0.8193 - val_loss: 0.4991 - val_recall: 0.8187\n",
      "Epoch 278/300\n",
      "400/400 [==============================] - 1s 2ms/step - loss: 0.4941 - recall: 0.8185 - val_loss: 0.5066 - val_recall: 0.8236\n",
      "Epoch 279/300\n",
      "400/400 [==============================] - 1s 2ms/step - loss: 0.4933 - recall: 0.8178 - val_loss: 0.4935 - val_recall: 0.8141\n",
      "Epoch 280/300\n",
      "400/400 [==============================] - 1s 2ms/step - loss: 0.4933 - recall: 0.8171 - val_loss: 0.4939 - val_recall: 0.8152\n",
      "Epoch 281/300\n",
      "400/400 [==============================] - 1s 2ms/step - loss: 0.4937 - recall: 0.8164 - val_loss: 0.4905 - val_recall: 0.8127\n",
      "Epoch 282/300\n",
      "400/400 [==============================] - 1s 2ms/step - loss: 0.4927 - recall: 0.8188 - val_loss: 0.4969 - val_recall: 0.8176\n",
      "Epoch 283/300\n",
      "400/400 [==============================] - 1s 2ms/step - loss: 0.4937 - recall: 0.8207 - val_loss: 0.4885 - val_recall: 0.8125\n",
      "Epoch 284/300\n",
      "400/400 [==============================] - 1s 2ms/step - loss: 0.4931 - recall: 0.8178 - val_loss: 0.4954 - val_recall: 0.8166\n",
      "Epoch 285/300\n",
      "400/400 [==============================] - 1s 2ms/step - loss: 0.4939 - recall: 0.8187 - val_loss: 0.5021 - val_recall: 0.8217\n",
      "Epoch 286/300\n",
      "400/400 [==============================] - 1s 2ms/step - loss: 0.4934 - recall: 0.8182 - val_loss: 0.4963 - val_recall: 0.8169\n",
      "Epoch 287/300\n",
      "400/400 [==============================] - 1s 2ms/step - loss: 0.4940 - recall: 0.8193 - val_loss: 0.4929 - val_recall: 0.8145\n",
      "Epoch 288/300\n",
      "400/400 [==============================] - 1s 2ms/step - loss: 0.4937 - recall: 0.8202 - val_loss: 0.5058 - val_recall: 0.8226\n",
      "Epoch 289/300\n",
      "400/400 [==============================] - 1s 2ms/step - loss: 0.4938 - recall: 0.8219 - val_loss: 0.4803 - val_recall: 0.8048\n",
      "Epoch 290/300\n",
      "400/400 [==============================] - 1s 2ms/step - loss: 0.4934 - recall: 0.8165 - val_loss: 0.4937 - val_recall: 0.8138\n",
      "Epoch 291/300\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "400/400 [==============================] - 1s 2ms/step - loss: 0.4930 - recall: 0.8176 - val_loss: 0.4960 - val_recall: 0.8159\n",
      "Epoch 292/300\n",
      "400/400 [==============================] - 1s 2ms/step - loss: 0.4935 - recall: 0.8184 - val_loss: 0.4886 - val_recall: 0.8120\n",
      "Epoch 293/300\n",
      "400/400 [==============================] - 1s 2ms/step - loss: 0.4942 - recall: 0.8175 - val_loss: 0.5002 - val_recall: 0.8180\n",
      "Epoch 294/300\n",
      "400/400 [==============================] - 1s 2ms/step - loss: 0.4923 - recall: 0.8186 - val_loss: 0.4899 - val_recall: 0.8122\n",
      "Epoch 295/300\n",
      "400/400 [==============================] - 1s 2ms/step - loss: 0.4945 - recall: 0.8161 - val_loss: 0.5034 - val_recall: 0.8213\n",
      "Epoch 296/300\n",
      "400/400 [==============================] - 1s 2ms/step - loss: 0.4943 - recall: 0.8204 - val_loss: 0.4978 - val_recall: 0.8169\n",
      "Epoch 297/300\n",
      "400/400 [==============================] - 1s 2ms/step - loss: 0.4929 - recall: 0.8176 - val_loss: 0.4941 - val_recall: 0.8150\n",
      "Epoch 298/300\n",
      "400/400 [==============================] - 1s 2ms/step - loss: 0.4948 - recall: 0.8202 - val_loss: 0.4971 - val_recall: 0.8155\n",
      "Epoch 299/300\n",
      "400/400 [==============================] - 1s 2ms/step - loss: 0.4932 - recall: 0.8159 - val_loss: 0.4937 - val_recall: 0.8138\n",
      "Epoch 300/300\n",
      "400/400 [==============================] - 1s 2ms/step - loss: 0.4926 - recall: 0.8177 - val_loss: 0.5000 - val_recall: 0.8187\n"
     ]
    }
   ],
   "source": [
    "estimator = Estimator.dnn_estimator\n",
    "estimator_name = \"Keras estimator DNN\"\n",
    "dropout_rate = 0.4\n",
    "activation = 'relu'\n",
    "hidden_layer_sizes=(60,30)\n",
    "loss = \"binary_crossentropy\"\n",
    "metrics= [tf.keras.metrics.Recall()]\n",
    "class_weight = {0: weight_for_0, 1: weight_for_1}\n",
    "epochs = 300\n",
    "batch_size = 512\n",
    "optimizer = \"SGD\"\n",
    "validation_split_fraction = 0.2\n",
    "\n",
    "model = create_model(dropout_rate=dropout_rate, hidden_layer_sizes=hidden_layer_sizes, activation=activation)\n",
    "model.compile(optimizer, loss=loss, metrics=metrics)\n",
    "\n",
    "history = model.fit(X_train, y_train, epochs=epochs, validation_split=validation_split_fraction, batch_size=batch_size, class_weight=class_weight)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1999/1999 [==============================] - 1s 555us/step\n",
      "Model: \"sequential\"\n",
      "_________________________________________________________________\n",
      " Layer (type)                Output Shape              Param #   \n",
      "=================================================================\n",
      " dense (Dense)               (None, 60)                1020      \n",
      "                                                                 \n",
      " dense_1 (Dense)             (None, 30)                1830      \n",
      "                                                                 \n",
      " dropout (Dropout)           (None, 30)                0         \n",
      "                                                                 \n",
      " dense_2 (Dense)             (None, 1)                 31        \n",
      "                                                                 \n",
      "=================================================================\n",
      "Total params: 2,881\n",
      "Trainable params: 2,881\n",
      "Non-trainable params: 0\n",
      "_________________________________________________________________\n",
      "None\n",
      "number of ones predicted: 21246\n",
      "number of zeros predicted: 42713\n",
      "Estimator                  Accuracy         Recall      Precision       F1 score       F2 score \n",
      "\n",
      "Keras estimator DNN          0.7214         0.8131         0.2095         0.3332         0.5159\n",
      "dict_keys(['loss', 'recall', 'val_loss', 'val_recall'])\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"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1080x1080 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "y_predicted_probas = model.predict(X_test)\n",
    "y_predicted = (y_predicted_probas > 0.5).astype(\"int32\")\n",
    "\n",
    "print(model.summary())\n",
    "print(\"number of ones predicted: {}\".format(np.count_nonzero(y_predicted == 1)))\n",
    "print(\"number of zeros predicted: {}\".format(np.count_nonzero(y_predicted == 0)))\n",
    "print_scores({estimator_name: get_scores(y_test, y_predicted)})\n",
    "\n",
    "# plot loss and accuracy  \n",
    "plot_loss(title=estimator_name, history=history)\n",
    "\n",
    "# plot roc\n",
    "number_of_rows, number_of_columns = 1, 2\n",
    "figure_index = 1\n",
    "figure = plt.figure(figsize=(15, 15))\n",
    "ax = figure.add_subplot(number_of_rows, number_of_columns, figure_index)\n",
    "plot_roc(title=estimator.name, ax=ax, y_test=y_test, y_predicted=y_predicted)\n",
    "figure_index += 1\n",
    "\n",
    "# plot learning curve\n",
    "ax = figure.add_subplot(number_of_rows, number_of_columns, figure_index)\n",
    "plot_learning_curve(title=estimator.name, estimator=estimator.value, ax=ax, X=X_train, y=y_train, cv=2)\n",
    "figure_index += 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Logistic Regression"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Fitting 2 folds for each of 27 candidates, totalling 54 fits\n",
      "Estimator                  Accuracy         Recall      Precision       F1 score       F2 score \n",
      "\n",
      "log_regr_estimator           0.7417         0.7806         0.2181          0.341          0.515\n",
      "Best parameters for log_regr_estimator: \n",
      "class_weight: {0: 0.5468029990852277, 1: 5.841538040003653}\n",
      "max_iter: 200\n",
      "solver: saga\n",
      "Coefficient     |value     |\n",
      "intercept       |-2.8209042864754195|\n",
      "AlcoholDrinking |  -0.18298|\n",
      "Stroke          |    1.2388|\n",
      "DiffWalking     |   0.33367|\n",
      "Sex             |  -0.74022|\n",
      "AgeCategory     |   3.50266|\n",
      "Diabetic        |   0.50805|\n",
      "PhysicalActivity|   0.00372|\n",
      "KidneyDisease   |   0.66044|\n",
      "SkinCancer      |   0.12221|\n",
      "breathing_risk  |   0.41598|\n",
      "BMI_sqrt        |   0.06056|\n",
      "GenHealth_squared|  -0.73752|\n",
      "GenHealth_squared_x_Age|   0.29711|\n",
      "GenHealth_squared_x_PhysicalHealth|  -0.13764|\n",
      "PhysicalHealth__x_DiffWalking|  -0.03056|\n",
      "PhysicalHealth_binned|   0.22706|\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1080x1080 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [
       "<style>#sk-container-id-3 {color: black;background-color: white;}#sk-container-id-3 pre{padding: 0;}#sk-container-id-3 div.sk-toggleable {background-color: white;}#sk-container-id-3 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-3 label.sk-toggleable__label-arrow:before {content: \"▸\";float: left;margin-right: 0.25em;color: #696969;}#sk-container-id-3 label.sk-toggleable__label-arrow:hover:before {color: black;}#sk-container-id-3 div.sk-estimator:hover label.sk-toggleable__label-arrow:before {color: black;}#sk-container-id-3 div.sk-toggleable__content {max-height: 0;max-width: 0;overflow: hidden;text-align: left;background-color: #f0f8ff;}#sk-container-id-3 div.sk-toggleable__content pre {margin: 0.2em;color: black;border-radius: 0.25em;background-color: #f0f8ff;}#sk-container-id-3 input.sk-toggleable__control:checked~div.sk-toggleable__content {max-height: 200px;max-width: 100%;overflow: auto;}#sk-container-id-3 input.sk-toggleable__control:checked~label.sk-toggleable__label-arrow:before {content: \"▾\";}#sk-container-id-3 div.sk-estimator input.sk-toggleable__control:checked~label.sk-toggleable__label {background-color: #d4ebff;}#sk-container-id-3 div.sk-label input.sk-toggleable__control:checked~label.sk-toggleable__label {background-color: #d4ebff;}#sk-container-id-3 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-3 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-3 div.sk-estimator:hover {background-color: #d4ebff;}#sk-container-id-3 div.sk-parallel-item::after {content: \"\";width: 100%;border-bottom: 1px solid gray;flex-grow: 1;}#sk-container-id-3 div.sk-label:hover label.sk-toggleable__label {background-color: #d4ebff;}#sk-container-id-3 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-3 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-3 div.sk-item {position: relative;z-index: 1;}#sk-container-id-3 div.sk-parallel {display: flex;align-items: stretch;justify-content: center;background-color: white;position: relative;}#sk-container-id-3 div.sk-item::before, #sk-container-id-3 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-3 div.sk-parallel-item {display: flex;flex-direction: column;z-index: 1;position: relative;background-color: white;}#sk-container-id-3 div.sk-parallel-item:first-child::after {align-self: flex-end;width: 50%;}#sk-container-id-3 div.sk-parallel-item:last-child::after {align-self: flex-start;width: 50%;}#sk-container-id-3 div.sk-parallel-item:only-child::after {width: 0;}#sk-container-id-3 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-3 div.sk-label label {font-family: monospace;font-weight: bold;display: inline-block;line-height: 1.2em;}#sk-container-id-3 div.sk-label-container {text-align: center;}#sk-container-id-3 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-3 div.sk-text-repr-fallback {display: none;}</style><div id=\"sk-container-id-3\" class=\"sk-top-container\"><div class=\"sk-text-repr-fallback\"><pre>GridSearchCV(cv=2, estimator=LogisticRegression(random_state=42), n_jobs=-1,\n",
       "             param_grid={&#x27;class_weight&#x27;: [{0: 1, 1: 1}, {0: 1, 1: 4},\n",
       "                                          {0: 0.5468029990852277,\n",
       "                                           1: 5.841538040003653}],\n",
       "                         &#x27;max_iter&#x27;: [200, 400, 1000],\n",
       "                         &#x27;solver&#x27;: [&#x27;sag&#x27;, &#x27;saga&#x27;, &#x27;lbfgs&#x27;]},\n",
       "             return_train_score=True, scoring=make_scorer(fbeta_score, beta=2),\n",
       "             verbose=3)</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 sk-dashed-wrapped\"><div class=\"sk-label-container\"><div class=\"sk-label sk-toggleable\"><input class=\"sk-toggleable__control sk-hidden--visually\" id=\"sk-estimator-id-7\" type=\"checkbox\" ><label for=\"sk-estimator-id-7\" class=\"sk-toggleable__label sk-toggleable__label-arrow\">GridSearchCV</label><div class=\"sk-toggleable__content\"><pre>GridSearchCV(cv=2, estimator=LogisticRegression(random_state=42), n_jobs=-1,\n",
       "             param_grid={&#x27;class_weight&#x27;: [{0: 1, 1: 1}, {0: 1, 1: 4},\n",
       "                                          {0: 0.5468029990852277,\n",
       "                                           1: 5.841538040003653}],\n",
       "                         &#x27;max_iter&#x27;: [200, 400, 1000],\n",
       "                         &#x27;solver&#x27;: [&#x27;sag&#x27;, &#x27;saga&#x27;, &#x27;lbfgs&#x27;]},\n",
       "             return_train_score=True, scoring=make_scorer(fbeta_score, beta=2),\n",
       "             verbose=3)</pre></div></div></div><div class=\"sk-parallel\"><div class=\"sk-parallel-item\"><div class=\"sk-item\"><div class=\"sk-label-container\"><div class=\"sk-label sk-toggleable\"><input class=\"sk-toggleable__control sk-hidden--visually\" id=\"sk-estimator-id-8\" type=\"checkbox\" ><label for=\"sk-estimator-id-8\" class=\"sk-toggleable__label sk-toggleable__label-arrow\">estimator: LogisticRegression</label><div class=\"sk-toggleable__content\"><pre>LogisticRegression(random_state=42)</pre></div></div></div><div class=\"sk-serial\"><div class=\"sk-item\"><div class=\"sk-estimator sk-toggleable\"><input class=\"sk-toggleable__control sk-hidden--visually\" id=\"sk-estimator-id-9\" type=\"checkbox\" ><label for=\"sk-estimator-id-9\" class=\"sk-toggleable__label sk-toggleable__label-arrow\">LogisticRegression</label><div class=\"sk-toggleable__content\"><pre>LogisticRegression(random_state=42)</pre></div></div></div></div></div></div></div></div></div></div>"
      ],
      "text/plain": [
       "GridSearchCV(cv=2, estimator=LogisticRegression(random_state=42), n_jobs=-1,\n",
       "             param_grid={'class_weight': [{0: 1, 1: 1}, {0: 1, 1: 4},\n",
       "                                          {0: 0.5468029990852277,\n",
       "                                           1: 5.841538040003653}],\n",
       "                         'max_iter': [200, 400, 1000],\n",
       "                         'solver': ['sag', 'saga', 'lbfgs']},\n",
       "             return_train_score=True, scoring=make_scorer(fbeta_score, beta=2),\n",
       "             verbose=3)"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# logistic regression estimator\n",
    "estimator = Estimator.log_regr_estimator\n",
    "model_evaluate(estimator, param_grids.get(estimator), **data_dict, cv_folds=2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "                           Logit Regression Results                           \n",
      "==============================================================================\n",
      "Dep. Variable:           HeartDisease   No. Observations:               255836\n",
      "Model:                          Logit   Df Residuals:                   255819\n",
      "Method:                           MLE   Df Model:                           16\n",
      "Date:                Mon, 05 Dec 2022   Pseudo R-squ.:                  0.2214\n",
      "Time:                        14:12:06   Log-Likelihood:                -58207.\n",
      "converged:                       True   LL-Null:                       -74761.\n",
      "Covariance Type:            nonrobust   LLR p-value:                     0.000\n",
      "======================================================================================================\n",
      "                                         coef    std err          z      P>|z|      [0.025      0.975]\n",
      "------------------------------------------------------------------------------------------------------\n",
      "AlcoholDrinking                       -0.2015      0.037     -5.413      0.000      -0.274      -0.129\n",
      "Stroke                                 1.0483      0.025     41.728      0.000       0.999       1.098\n",
      "DiffWalking                            0.2635      0.028      9.470      0.000       0.209       0.318\n",
      "Sex                                   -0.7145      0.016    -44.826      0.000      -0.746      -0.683\n",
      "AgeCategory                            3.4527      0.047     73.605      0.000       3.361       3.545\n",
      "Diabetic                               0.4685      0.018     25.668      0.000       0.433       0.504\n",
      "PhysicalActivity                       0.0140      0.018      0.792      0.428      -0.021       0.049\n",
      "KidneyDisease                          0.6104      0.027     22.771      0.000       0.558       0.663\n",
      "SkinCancer                             0.1183      0.022      5.501      0.000       0.076       0.160\n",
      "breathing_risk                         0.3869      0.016     23.719      0.000       0.355       0.419\n",
      "BMI_sqrt                               0.0595      0.008      7.303      0.000       0.044       0.076\n",
      "GenHealth_squared                     -0.9148      0.037    -24.595      0.000      -0.988      -0.842\n",
      "GenHealth_squared_x_Age                0.5112      0.046     11.194      0.000       0.422       0.601\n",
      "GenHealth_squared_x_PhysicalHealth    -0.1862      0.026     -7.275      0.000      -0.236      -0.136\n",
      "PhysicalHealth__x_DiffWalking         -0.0114      0.040     -0.283      0.777      -0.090       0.067\n",
      "PhysicalHealth_binned                  0.1003      0.033      3.076      0.002       0.036       0.164\n",
      "const                                 -5.1173      0.041   -125.112      0.000      -5.197      -5.037\n",
      "======================================================================================================\n",
      "                                           OR   Lower CI   Upper CI\n",
      "AlcoholDrinking                      0.817528   0.760013   0.879397\n",
      "Stroke                               2.852827   2.715759   2.996812\n",
      "DiffWalking                          1.301447   1.232378   1.374388\n",
      "Sex                                  0.489432   0.474378   0.504963\n",
      "AgeCategory                         31.585802  28.811321  34.627460\n",
      "Diabetic                             1.597562   1.541423   1.655745\n",
      "PhysicalActivity                     1.014123   0.979543   1.049923\n",
      "KidneyDisease                        1.841186   1.746946   1.940508\n",
      "SkinCancer                           1.125543   1.079097   1.173987\n",
      "breathing_risk                       1.472433   1.426101   1.520270\n",
      "BMI_sqrt                             1.061348   1.044525   1.078443\n",
      "GenHealth_squared                    0.400598   0.372434   0.430892\n",
      "GenHealth_squared_x_Age              1.667225   1.524495   1.823318\n",
      "GenHealth_squared_x_PhysicalHealth   0.830106   0.789493   0.872807\n",
      "PhysicalHealth__x_DiffWalking        0.988678   0.913822   1.069665\n",
      "PhysicalHealth_binned                1.105466   1.037053   1.178391\n",
      "const                                0.005992   0.005531   0.006492\n"
     ]
    }
   ],
   "source": [
    "iters = 200\n",
    "method = \"lbfgs\"\n",
    "log_regr_model_statsmodels = sm.Logit(y_train,  sm.add_constant(X_train, prepend=False))\n",
    "log_regr_res_statsmodels = log_regr_model_statsmodels.fit(maxiter=iters, method=method)\n",
    "print(log_regr_res_statsmodels.summary())\n",
    "\n",
    "odds_ratios = pd.DataFrame(\n",
    "    {\n",
    "        \"OR\": log_regr_res_statsmodels.params,\n",
    "        \"Lower CI\": log_regr_res_statsmodels.conf_int()[0],\n",
    "        \"Upper CI\": log_regr_res_statsmodels.conf_int()[1],\n",
    "    }\n",
    ")\n",
    "odds_ratios = np.exp(odds_ratios)\n",
    "print(odds_ratios)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "                                   Results: Logit\n",
      "====================================================================================\n",
      "Model:                    Logit                  Pseudo R-squared:       0.221      \n",
      "Dependent Variable:       HeartDisease           AIC:                    116447.3740\n",
      "Date:                     2022-12-05 14:05       BIC:                    116625.0630\n",
      "No. Observations:         255836                 Log-Likelihood:         -58207.    \n",
      "Df Model:                 16                     LL-Null:                -74761.    \n",
      "Df Residuals:             255819                 LLR p-value:            0.0000     \n",
      "Converged:                1.0000                 Scale:                  1.0000     \n",
      "------------------------------------------------------------------------------------\n",
      "                                    Coef.  Std.Err.     z     P>|z|   [0.025  0.975]\n",
      "------------------------------------------------------------------------------------\n",
      "AlcoholDrinking                    -0.2016   0.0372   -5.4156 0.0000 -0.2745 -0.1286\n",
      "Stroke                              1.0484   0.0251   41.7329 0.0000  0.9991  1.0976\n",
      "DiffWalking                         0.2648   0.0278    9.5210 0.0000  0.2103  0.3194\n",
      "Sex                                -0.7146   0.0159  -44.8319 0.0000 -0.7458 -0.6833\n",
      "AgeCategory                         3.4554   0.0469   73.6377 0.0000  3.3634  3.5474\n",
      "Diabetic                            0.4680   0.0183   25.6423 0.0000  0.4322  0.5038\n",
      "PhysicalActivity                    0.0150   0.0177    0.8450 0.3981 -0.0197  0.0497\n",
      "KidneyDisease                       0.6102   0.0268   22.7630 0.0000  0.5577  0.6627\n",
      "SkinCancer                          0.1180   0.0215    5.4887 0.0000  0.0759  0.1601\n",
      "breathing_risk                      0.3869   0.0163   23.7174 0.0000  0.3549  0.4188\n",
      "BMI_sqrt                            0.0595   0.0082    7.3026 0.0000  0.0436  0.0755\n",
      "GenHealth_squared                  -0.9168   0.0372  -24.6369 0.0000 -0.9897 -0.8438\n",
      "GenHealth_squared_x_Age             0.5140   0.0457   11.2528 0.0000  0.4245  0.6035\n",
      "GenHealth_squared_x_PhysicalHealth -0.1860   0.0256   -7.2693 0.0000 -0.2362 -0.1359\n",
      "PhysicalHealth__x_DiffWalking      -0.0123   0.0402   -0.3063 0.7594 -0.0910  0.0664\n",
      "PhysicalHealth_binned               0.1006   0.0326    3.0872 0.0020  0.0367  0.1645\n",
      "const                              -5.1198   0.0409 -125.1219 0.0000 -5.2000 -5.0396\n",
      "====================================================================================\n",
      "\n"
     ]
    }
   ],
   "source": [
    "print(log_regr_res_statsmodels.summary2())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tp | 5391 fn: 84\n",
      "fp | 44410 tn: 14074\n",
      "              precision    recall  f1-score   support\n",
      "\n",
      "           0       0.99      0.24      0.39     58484\n",
      "           1       0.11      0.98      0.20      5475\n",
      "\n",
      "    accuracy                           0.30     63959\n",
      "   macro avg       0.55      0.61      0.29     63959\n",
      "weighted avg       0.92      0.30      0.37     63959\n",
      "\n",
      "f2: 0.3759361794117237\n"
     ]
    }
   ],
   "source": [
    "y_pred = log_regr_res_statsmodels.predict(sm.add_constant(X_test, prepend=False))\n",
    "\n",
    "decision_boundary = 0.1\n",
    "\n",
    "y_pred.loc[y_pred >= decision_boundary] = 1\n",
    "y_pred.loc[y_pred < decision_boundary] = 0\n",
    "\n",
    "from sklearn.metrics import confusion_matrix\n",
    "tn, fp, fn, tp= confusion_matrix(y_test, y_pred).ravel()\n",
    "\n",
    "print(\"tp | {} fn: {}\\nfp | {} tn: {}\".format(tp, fn, fp, tn))\n",
    "\n",
    "from sklearn.metrics import classification_report\n",
    "print(classification_report(y_test, y_pred))\n",
    "\n",
    "f2 = fbeta_score(y_test, y_pred, beta=2, average='binary')\n",
    "print(\"f2: {}\".format(f2))"
   ]
  }
 ],
 "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.3"
  },
  "vscode": {
   "interpreter": {
    "hash": "26de051ba29f2982a8de78e945f0abaf191376122a1563185a90213a26c5da77"
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}