Binary_classification.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "Binary classification.ipynb",
      "provenance": [],
      "collapsed_sections": []
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "source": [
        "Shibu Mohapatra\n",
        "\n",
        "Artificial Intelligence"
      ],
      "metadata": {
        "id": "IDGVUX9hlWk6"
      }
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Je_hFiy9IEL3"
      },
      "source": [
        "**Binary classification using Python and interpret and predict the output for given data.**"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# modules\n",
        "import pandas as pd\n",
        "import numpy as np\n",
        "import matplotlib.pyplot as plt\n",
        "from sklearn.preprocessing import LabelEncoder\n",
        "from keras.wrappers.scikit_learn import KerasClassifier\n",
        "from keras.utils import np_utils\n",
        "\n",
        "# for modeling\n",
        "from keras.models import Sequential\n",
        "from keras.layers import Dense, Dropout\n",
        "from keras.callbacks import EarlyStopping"
      ],
      "metadata": {
        "id": "g2gteTqccLDY"
      },
      "execution_count": 23,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# read data\n",
        "df = pd.read_csv('https://raw.githubusercontent.com/agconti/kaggle-titanic/master/data/train.csv')\n",
        "df.info()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "t0JGzZChcWjk",
        "outputId": "f7b7291e-9989-4d0b-aa99-a16bb4872020"
      },
      "execution_count": 24,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "<class 'pandas.core.frame.DataFrame'>\n",
            "RangeIndex: 891 entries, 0 to 890\n",
            "Data columns (total 12 columns):\n",
            " #   Column       Non-Null Count  Dtype  \n",
            "---  ------       --------------  -----  \n",
            " 0   PassengerId  891 non-null    int64  \n",
            " 1   Survived     891 non-null    int64  \n",
            " 2   Pclass       891 non-null    int64  \n",
            " 3   Name         891 non-null    object \n",
            " 4   Sex          891 non-null    object \n",
            " 5   Age          714 non-null    float64\n",
            " 6   SibSp        891 non-null    int64  \n",
            " 7   Parch        891 non-null    int64  \n",
            " 8   Ticket       891 non-null    object \n",
            " 9   Fare         891 non-null    float64\n",
            " 10  Cabin        204 non-null    object \n",
            " 11  Embarked     889 non-null    object \n",
            "dtypes: float64(2), int64(5), object(5)\n",
            "memory usage: 83.7+ KB\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# delete the cabin column\n",
        "df.drop(['Cabin'], axis=1, inplace=True)\n",
        "\n",
        "# impute the 'Age' column\n",
        "df['Age'].fillna(df['Age'].mean(), inplace=True)\n",
        "\n",
        "# ditch the two rows from 'Embarked'\n",
        "df.dropna(inplace=True)\n",
        "df.info()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "e2Z30ocmcZ9w",
        "outputId": "bd01364c-b0f4-4c4f-e09f-901af16a6b4f"
      },
      "execution_count": 25,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "<class 'pandas.core.frame.DataFrame'>\n",
            "Int64Index: 889 entries, 0 to 890\n",
            "Data columns (total 11 columns):\n",
            " #   Column       Non-Null Count  Dtype  \n",
            "---  ------       --------------  -----  \n",
            " 0   PassengerId  889 non-null    int64  \n",
            " 1   Survived     889 non-null    int64  \n",
            " 2   Pclass       889 non-null    int64  \n",
            " 3   Name         889 non-null    object \n",
            " 4   Sex          889 non-null    object \n",
            " 5   Age          889 non-null    float64\n",
            " 6   SibSp        889 non-null    int64  \n",
            " 7   Parch        889 non-null    int64  \n",
            " 8   Ticket       889 non-null    object \n",
            " 9   Fare         889 non-null    float64\n",
            " 10  Embarked     889 non-null    object \n",
            "dtypes: float64(2), int64(5), object(4)\n",
            "memory usage: 83.3+ KB\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# drop unncessary columns from train and testdf\n",
        "df.drop(['PassengerId', 'Name', 'Ticket'], axis=1, inplace=True)\n",
        "\n",
        "# recode the sex column\n",
        "df['Sex'].replace(('male', 'female'), (0, 1), inplace=True)\n",
        "\n",
        "# recode the embarked column\n",
        "df['Embarked'].replace(('Q', 'S', 'C'), (0, 1, 2), inplace=True)\n",
        "\n",
        "df.info()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "QYYly1qOc5qX",
        "outputId": "89caba3d-bddc-4dd1-bff0-6aa64e04cc7b"
      },
      "execution_count": 26,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "<class 'pandas.core.frame.DataFrame'>\n",
            "Int64Index: 889 entries, 0 to 890\n",
            "Data columns (total 8 columns):\n",
            " #   Column    Non-Null Count  Dtype  \n",
            "---  ------    --------------  -----  \n",
            " 0   Survived  889 non-null    int64  \n",
            " 1   Pclass    889 non-null    int64  \n",
            " 2   Sex       889 non-null    int64  \n",
            " 3   Age       889 non-null    float64\n",
            " 4   SibSp     889 non-null    int64  \n",
            " 5   Parch     889 non-null    int64  \n",
            " 6   Fare      889 non-null    float64\n",
            " 7   Embarked  889 non-null    int64  \n",
            "dtypes: float64(2), int64(6)\n",
            "memory usage: 62.5 KB\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# check distribution of target variable\n",
        "df['Survived'].value_counts()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "wmxDBmt1dEhr",
        "outputId": "08c53f0a-2d21-4086-d1bd-b935b73860a0"
      },
      "execution_count": 27,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "0    549\n",
              "1    340\n",
              "Name: Survived, dtype: int64"
            ]
          },
          "metadata": {},
          "execution_count": 27
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "(549/(549+340))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "x1S7o9R_dGj1",
        "outputId": "afb9e9c5-a998-4ec9-c74c-dbbff3f8abdb"
      },
      "execution_count": 28,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "0.6175478065241845"
            ]
          },
          "metadata": {},
          "execution_count": 28
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "Y = df['Survived']\n",
        "X = df.drop(['Survived'], axis=1)\n",
        "\n",
        "print(X.shape)\n",
        "print(Y.shape)\n",
        "X = np.array(X)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "j95VFud6dJP-",
        "outputId": "a8201f52-4778-46b3-836b-e155033f25ec"
      },
      "execution_count": 29,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "(889, 7)\n",
            "(889,)\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# build a model\n",
        "model = Sequential()\n",
        "model.add(Dense(16, input_shape=(X.shape[1],), activation='relu')) # Add an input shape! (features,)\n",
        "model.add(Dense(16, activation='relu'))\n",
        "model.add(Dense(1, activation='sigmoid'))\n",
        "model.summary() \n",
        "\n",
        "# compile the model\n",
        "model.compile(optimizer='Adam', \n",
        "              loss='binary_crossentropy',\n",
        "              metrics=['accuracy'])\n",
        "\n",
        "# early stopping callback\n",
        "# This callback will stop the training when there is no improvement in  \n",
        "# the validation loss for 10 consecutive epochs.  \n",
        "es = EarlyStopping(monitor='val_accuracy', \n",
        "                                   mode='max', # don't minimize the accuracy!\n",
        "                                   patience=10,\n",
        "                                   restore_best_weights=True)\n",
        "\n",
        "# model fit call\n",
        "history = model.fit(X,\n",
        "                    Y,\n",
        "                    callbacks=[es],\n",
        "                    epochs=80, # you can set this to a big number!\n",
        "                    batch_size=10,\n",
        "                    validation_split=0.2,\n",
        "                    shuffle=True,\n",
        "                    verbose=1)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "YFSL48FBdM_W",
        "outputId": "47be7e3e-6cc9-4820-e158-c29b6a632738"
      },
      "execution_count": 30,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Model: \"sequential_2\"\n",
            "_________________________________________________________________\n",
            " Layer (type)                Output Shape              Param #   \n",
            "=================================================================\n",
            " dense_6 (Dense)             (None, 16)                128       \n",
            "                                                                 \n",
            " dense_7 (Dense)             (None, 16)                272       \n",
            "                                                                 \n",
            " dense_8 (Dense)             (None, 1)                 17        \n",
            "                                                                 \n",
            "=================================================================\n",
            "Total params: 417\n",
            "Trainable params: 417\n",
            "Non-trainable params: 0\n",
            "_________________________________________________________________\n",
            "Epoch 1/80\n",
            "72/72 [==============================] - 1s 4ms/step - loss: 1.7698 - accuracy: 0.5134 - val_loss: 0.5600 - val_accuracy: 0.7022\n",
            "Epoch 2/80\n",
            "72/72 [==============================] - 0s 2ms/step - loss: 0.6319 - accuracy: 0.6709 - val_loss: 0.5740 - val_accuracy: 0.6966\n",
            "Epoch 3/80\n",
            "72/72 [==============================] - 0s 2ms/step - loss: 0.6057 - accuracy: 0.6751 - val_loss: 0.5935 - val_accuracy: 0.7191\n",
            "Epoch 4/80\n",
            "72/72 [==============================] - 0s 2ms/step - loss: 0.6197 - accuracy: 0.6667 - val_loss: 0.5399 - val_accuracy: 0.7191\n",
            "Epoch 5/80\n",
            "72/72 [==============================] - 0s 3ms/step - loss: 0.6163 - accuracy: 0.6737 - val_loss: 0.5170 - val_accuracy: 0.7135\n",
            "Epoch 6/80\n",
            "72/72 [==============================] - 0s 2ms/step - loss: 0.6117 - accuracy: 0.6850 - val_loss: 0.5136 - val_accuracy: 0.7416\n",
            "Epoch 7/80\n",
            "72/72 [==============================] - 0s 2ms/step - loss: 0.5816 - accuracy: 0.7004 - val_loss: 0.5105 - val_accuracy: 0.7584\n",
            "Epoch 8/80\n",
            "72/72 [==============================] - 0s 2ms/step - loss: 0.5818 - accuracy: 0.6934 - val_loss: 0.5024 - val_accuracy: 0.7640\n",
            "Epoch 9/80\n",
            "72/72 [==============================] - 0s 2ms/step - loss: 0.5866 - accuracy: 0.7046 - val_loss: 0.4858 - val_accuracy: 0.7584\n",
            "Epoch 10/80\n",
            "72/72 [==============================] - 0s 2ms/step - loss: 0.5703 - accuracy: 0.7103 - val_loss: 0.4805 - val_accuracy: 0.7697\n",
            "Epoch 11/80\n",
            "72/72 [==============================] - 0s 2ms/step - loss: 0.5647 - accuracy: 0.7060 - val_loss: 0.4798 - val_accuracy: 0.7809\n",
            "Epoch 12/80\n",
            "72/72 [==============================] - 0s 2ms/step - loss: 0.5557 - accuracy: 0.7426 - val_loss: 0.5690 - val_accuracy: 0.7135\n",
            "Epoch 13/80\n",
            "72/72 [==============================] - 0s 2ms/step - loss: 0.5390 - accuracy: 0.7314 - val_loss: 0.4663 - val_accuracy: 0.8034\n",
            "Epoch 14/80\n",
            "72/72 [==============================] - 0s 2ms/step - loss: 0.5611 - accuracy: 0.7257 - val_loss: 0.5099 - val_accuracy: 0.6910\n",
            "Epoch 15/80\n",
            "72/72 [==============================] - 0s 2ms/step - loss: 0.5894 - accuracy: 0.7300 - val_loss: 0.5130 - val_accuracy: 0.7584\n",
            "Epoch 16/80\n",
            "72/72 [==============================] - 0s 2ms/step - loss: 0.5178 - accuracy: 0.7468 - val_loss: 0.4636 - val_accuracy: 0.8315\n",
            "Epoch 17/80\n",
            "72/72 [==============================] - 0s 2ms/step - loss: 0.5229 - accuracy: 0.7609 - val_loss: 0.4595 - val_accuracy: 0.7865\n",
            "Epoch 18/80\n",
            "72/72 [==============================] - 0s 2ms/step - loss: 0.5121 - accuracy: 0.7581 - val_loss: 0.4631 - val_accuracy: 0.8146\n",
            "Epoch 19/80\n",
            "72/72 [==============================] - 0s 2ms/step - loss: 0.5209 - accuracy: 0.7623 - val_loss: 0.4507 - val_accuracy: 0.8202\n",
            "Epoch 20/80\n",
            "72/72 [==============================] - 0s 2ms/step - loss: 0.5317 - accuracy: 0.7412 - val_loss: 0.4297 - val_accuracy: 0.8371\n",
            "Epoch 21/80\n",
            "72/72 [==============================] - 0s 2ms/step - loss: 0.5082 - accuracy: 0.7693 - val_loss: 0.4157 - val_accuracy: 0.8371\n",
            "Epoch 22/80\n",
            "72/72 [==============================] - 0s 2ms/step - loss: 0.4894 - accuracy: 0.7707 - val_loss: 0.4286 - val_accuracy: 0.8315\n",
            "Epoch 23/80\n",
            "72/72 [==============================] - 0s 2ms/step - loss: 0.5044 - accuracy: 0.7792 - val_loss: 0.4033 - val_accuracy: 0.8483\n",
            "Epoch 24/80\n",
            "72/72 [==============================] - 0s 2ms/step - loss: 0.4830 - accuracy: 0.7904 - val_loss: 0.4056 - val_accuracy: 0.8483\n",
            "Epoch 25/80\n",
            "72/72 [==============================] - 0s 2ms/step - loss: 0.4845 - accuracy: 0.7806 - val_loss: 0.4118 - val_accuracy: 0.8315\n",
            "Epoch 26/80\n",
            "72/72 [==============================] - 0s 2ms/step - loss: 0.4975 - accuracy: 0.7792 - val_loss: 0.3877 - val_accuracy: 0.8483\n",
            "Epoch 27/80\n",
            "72/72 [==============================] - 0s 2ms/step - loss: 0.4755 - accuracy: 0.7820 - val_loss: 0.3899 - val_accuracy: 0.8483\n",
            "Epoch 28/80\n",
            "72/72 [==============================] - 0s 2ms/step - loss: 0.4734 - accuracy: 0.7890 - val_loss: 0.4076 - val_accuracy: 0.8371\n",
            "Epoch 29/80\n",
            "72/72 [==============================] - 0s 2ms/step - loss: 0.4731 - accuracy: 0.7834 - val_loss: 0.4637 - val_accuracy: 0.7865\n",
            "Epoch 30/80\n",
            "72/72 [==============================] - 0s 2ms/step - loss: 0.4856 - accuracy: 0.7848 - val_loss: 0.4360 - val_accuracy: 0.8034\n",
            "Epoch 31/80\n",
            "72/72 [==============================] - 0s 2ms/step - loss: 0.4777 - accuracy: 0.7806 - val_loss: 0.3736 - val_accuracy: 0.8483\n",
            "Epoch 32/80\n",
            "72/72 [==============================] - 0s 2ms/step - loss: 0.4652 - accuracy: 0.7890 - val_loss: 0.4373 - val_accuracy: 0.8146\n",
            "Epoch 33/80\n",
            "72/72 [==============================] - 0s 2ms/step - loss: 0.5054 - accuracy: 0.7904 - val_loss: 0.4879 - val_accuracy: 0.7978\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "history_dict = history.history\n",
        "# Learning curve(Loss)\n",
        "# tthe training and validation loss by epoch\n",
        "\n",
        "# loss\n",
        "loss_values = history_dict['loss'] # you can change this\n",
        "val_loss_values = history_dict['val_loss'] # you can also change this\n",
        "\n",
        "# range of X (no. of epochs)\n",
        "epochs = range(1, len(loss_values) + 1) \n",
        "\n",
        "# plot\n",
        "plt.plot(epochs, loss_values, 'bo', label='Training loss')\n",
        "plt.plot(epochs, val_loss_values, 'orange', label='Validation loss')\n",
        "plt.title('Training and validation loss')\n",
        "plt.xlabel('Epochs')\n",
        "plt.ylabel('Loss')\n",
        "plt.legend()\n",
        "plt.show()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 295
        },
        "id": "3JBVyIQ9ddhN",
        "outputId": "6e36604c-7a72-4db9-c93e-fb443c724ac4"
      },
      "execution_count": 31,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYIAAAEWCAYAAABrDZDcAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAAgAElEQVR4nO3deXxU5dn/8c8FibIkgiyisltFK2sgiIoLqH0EteJCVcqjUqqordpqrUvVQu3D8+uvtX2sP7dSFW2Joo8LLmjFBURcKqCIoriDBpF9NSxJuH5/3CdhCFkmyUwmw3zfr9e8Zuace8655gTONfdy7mPujoiIZK4mqQ5ARERSS4lARCTDKRGIiGQ4JQIRkQynRCAikuGUCEREMpwSgSSUmT1vZhcmumwqmdkSMzspCdt1Mzs4en2Pmd0cT9k67Ge0mc2oa5zVbHeImRUmervS8LJSHYCknpltjnnbAtgGlEbvL3H3gni35e7Dk1F2T+fulyZiO2bWDfgSyHb3kmjbBUDcf0PJPEoEgrvnlL02syXARe7+UsVyZpZVdnIRkT2HmoakSmVVfzO7zsy+BSab2b5m9qyZrTKzddHrTjGfmWVmF0Wvx5jZHDO7NSr7pZkNr2PZ7mY228w2mdlLZnanmU2pIu54Yvy9mb0ebW+GmbWLWX++mS01szVmdmM1x2eQmX1rZk1jlp1pZguj10eY2Ztmtt7MlpvZHWa2VxXbesDM/ivm/a+jz3xjZmMrlD3VzN41s41m9rWZTYhZPTt6Xm9mm83sqLJjG/P5o81srpltiJ6PjvfYVMfMvh99fr2ZLTKz02PWnWJmH0bbXGZm10TL20V/n/VmttbMXjMznZcamA641GR/oA3QFRhH+DczOXrfBdgC3FHN5wcBHwPtgD8C95mZ1aHsQ8DbQFtgAnB+NfuMJ8YfAz8B9gP2AspOTIcDd0fbPzDaXycq4e7/Br4DTqiw3Yei16XAVdH3OQo4EfhZNXETxTAsiucHwCFAxf6J74ALgNbAqcBlZnZGtO646Lm1u+e4+5sVtt0GmA7cHn23vwDTzaxthe+w27GpIeZs4BlgRvS5K4ACMzs0KnIfoZkxF+gFvBIt/xVQCLQHOgC/ATTvTQNTIpCa7ADGu/s2d9/i7mvc/XF3L3L3TcBE4PhqPr/U3f/u7qXAg8ABhP/wcZc1sy7AQOC37r7d3ecAT1e1wzhjnOzun7j7FuBRoF+0fCTwrLvPdvdtwM3RMajKw8AoADPLBU6JluHu8939LXcvcfclwN8qiaMy50TxfeDu3xESX+z3m+Xu77v7DndfGO0vnu1CSByfuvs/o7geBhYDP4wpU9Wxqc6RQA7wh+hv9ArwLNGxAYqBw81sH3df5+7vxCw/AOjq7sXu/pprArQGp0QgNVnl7lvL3phZCzP7W9R0spHQFNE6tnmkgm/LXrh7UfQyp5ZlDwTWxiwD+LqqgOOM8duY10UxMR0Yu+3oRLymqn0Rfv2fZWZ7A2cB77j70iiOHlGzx7dRHP9NqB3UZJcYgKUVvt8gM5sZNX1tAC6Nc7tl215aYdlSoGPM+6qOTY0xu3ts0ozd7tmEJLnUzF41s6Oi5X8CPgNmmNkXZnZ9fF9DEkmJQGpS8dfZr4BDgUHuvg87myKqau5JhOVAGzNrEbOsczXl6xPj8thtR/tsW1Vhd/+QcMIbzq7NQhCamBYDh0Rx/KYuMRCat2I9RKgRdXb3VsA9Mdut6df0N4Qms1hdgGVxxFXTdjtXaN8v3667z3X3EYRmo2mEmgbuvsndf+XuBwGnA1eb2Yn1jEVqSYlAaiuX0Oa+PmpvHp/sHUa/sOcBE8xsr+jX5A+r+Uh9YnwMOM3Mjok6dm+h5v8nDwG/ICSc/60Qx0Zgs5kdBlwWZwyPAmPM7PAoEVWMP5dQQ9pqZkcQElCZVYSmrIOq2PZzQA8z+7GZZZnZucDhhGac+vg3ofZwrZllm9kQwt9oavQ3G21mrdy9mHBMdgCY2WlmdnDUF7SB0K9SXVOcJIESgdTWbUBzYDXwFvCvBtrvaEKH6xrgv4BHCNc7VKbOMbr7IuDnhJP7cmAdoTOzOmVt9K+4++qY5dcQTtKbgL9HMccTw/PRd3iF0GzySoUiPwNuMbNNwG+Jfl1Hny0i9Im8Ho3EObLCttcApxFqTWuAa4HTKsRda+6+nXDiH0447ncBF7j74qjI+cCSqInsUsLfE0Jn+EvAZuBN4C53n1mfWKT2TP0yko7M7BFgsbsnvUYisqdTjUDSgpkNNLPvmVmTaHjlCEJbs4jUk64slnSxP/AEoeO2ELjM3d9NbUgiewY1DYmIZDg1DYmIZLi0axpq166dd+vWLdVhiIiklfnz56929/aVrUu7RNCtWzfmzZuX6jBERNKKmVW8orycmoZERDJc0hKBmd1vZivN7IMq1rcys2fM7L1oytqfJCsWERGpWjJrBA8Aw6pZ/3PgQ3fvCwwB/lzVXO0iIpI8SesjcPfZFm6bV2URIDeaYyQHWAvo7lcijVBxcTGFhYVs3bq15sKSUs2aNaNTp05kZ2fH/ZlUdhbfQZhB8RvCJFrnVpjCtpyZjSPcFIUuXSpOxCgiyVZYWEhubi7dunWj6vsKSaq5O2vWrKGwsJDu3bvH/blUdhafDCwgzGPeD7jDzPaprKC7T3L3fHfPb9++0tFP1SoogG7doEmT8Fyg23iL1MrWrVtp27atkkAjZ2a0bdu21jW3VCaCnwBPePAZ8CVwWKJ3UlAA48bB0qXgHp7HjVMyEKktJYH0UJe/UyoTwVeEe7hiZh0INxL5ItE7ufFGKCradVlRUVguIiLJHT76MGF+8UPNrNDMfmpml5rZpVGR3wNHm9n7wMvAdfWdE70yX31Vu+Ui0visWbOGfv360a9fP/bff386duxY/n779u3VfnbevHlceeWVNe7j6KOPTkiss2bN4rTTTkvIthpKMkcNjaph/TfAfyRr/2W6dAnNQZUtF5HkKCgIte6vvgr/1yZOhNGja/5cVdq2bcuCBQsAmDBhAjk5OVxzzTXl60tKSsjKqvx0lp+fT35+fo37eOONN+oeYJrb468snjgRWrTYdVmLFmG5iCReQ/XLjRkzhksvvZRBgwZx7bXX8vbbb3PUUUeRl5fH0Ucfzccffwzs+gt9woQJjB07liFDhnDQQQdx++23l28vJyenvPyQIUMYOXIkhx12GKNHj6ZslubnnnuOww47jAEDBnDllVfW+Mt/7dq1nHHGGfTp04cjjzyShQsXAvDqq6+W12jy8vLYtGkTy5cv57jjjqNfv3706tWL1157LbEHrBppN9dQbZX9CknkrxMRqVp1/XKJ/n9XWFjIG2+8QdOmTdm4cSOvvfYaWVlZvPTSS/zmN7/h8ccf3+0zixcvZubMmWzatIlDDz2Uyy67bLcx9++++y6LFi3iwAMPZPDgwbz++uvk5+dzySWXMHv2bLp3786oUdU2egAwfvx48vLymDZtGq+88goXXHABCxYs4NZbb+XOO+9k8ODBbN68mWbNmjFp0iROPvlkbrzxRkpLSymqeBCTaI9PBBD+8enEL9IwGrJf7kc/+hFNmzYFYMOGDVx44YV8+umnmBnFxcWVfubUU09l7733Zu+992a//fZjxYoVdOrUaZcyRxxxRPmyfv36sWTJEnJycjjooIPKx+ePGjWKSZMmVRvfnDlzypPRCSecwJo1a9i4cSODBw/m6quvZvTo0Zx11ll06tSJgQMHMnbsWIqLiznjjDPo169fvY5NbezxTUMi0rCq6n9LRr9cy5Yty1/ffPPNDB06lA8++IBnnnmmyrH0e++9d/nrpk2bUlKy+4QG8ZSpj+uvv557772XLVu2MHjwYBYvXsxxxx3H7Nmz6dixI2PGjOEf//hHQvdZHSUCEUmoVPXLbdiwgY4dOwLwwAMPJHz7hx56KF988QVLliwB4JFHHqnxM8ceeywFUefIrFmzaNeuHfvssw+ff/45vXv35rrrrmPgwIEsXryYpUuX0qFDBy6++GIuuugi3nnnnYR/h6ooEYhIQo0eDZMmQdeuYBaeJ01KfvPstddeyw033EBeXl7Cf8EDNG/enLvuuothw4YxYMAAcnNzadWqVbWfmTBhAvPnz6dPnz5cf/31PPjggwDcdttt9OrViz59+pCdnc3w4cOZNWsWffv2JS8vj0ceeYRf/OIXCf8OVUm7exbn5+e7bkwj0rA++ugjvv/976c6jJTbvHkzOTk5uDs///nPOeSQQ7jqqqtSHdZuKvt7mdl8d690HK1qBCIicfr73/9Ov3796NmzJxs2bOCSSy5JdUgJkRGjhkREEuGqq65qlDWA+lKNQEQkwykRiIhkOCUCEZEMp0QgIpLhlAhEpNEbOnQoL7zwwi7LbrvtNi677LIqPzNkyBDKhpqfcsoprF+/frcyEyZM4NZbb61239OmTePDDz8sf//b3/6Wl156qTbhV6oxTVetRCAijd6oUaOYOnXqLsumTp0a18RvEGYNbd26dZ32XTER3HLLLZx00kl12lZjpUQgIo3eyJEjmT59evlNaJYsWcI333zDsccey2WXXUZ+fj49e/Zk/PjxlX6+W7durF4d7ns1ceJEevTowTHHHFM+VTWEawQGDhxI3759OfvssykqKuKNN97g6aef5te//jX9+vXj888/Z8yYMTz22GMAvPzyy+Tl5dG7d2/Gjh3Ltm3byvc3fvx4+vfvT+/evVm8eHG13y/V01XrOgIRqZ35v4R1CxK7zX37wYDbqlzdpk0bjjjiCJ5//nlGjBjB1KlTOeecczAzJk6cSJs2bSgtLeXEE09k4cKF9OnTp/LQ589n6tSpLFiwgJKSEvr378+AAQMAOOuss7j44osBuOmmm7jvvvu44oorOP300znttNMYOXLkLtvaunUrY8aM4eWXX6ZHjx5ccMEF3H333fzyl78EoF27drzzzjvcdddd3Hrrrdx7771Vfr9UT1etGoGIpIXY5qHYZqFHH32U/v37k5eXx6JFi3Zpxqnotdde48wzz6RFixbss88+nH766eXrPvjgA4499lh69+5NQUEBixYtqjaejz/+mO7du9OjRw8ALrzwQmbPnl2+/qyzzgJgwIAB5RPVVWXOnDmcf/75QOXTVd9+++2sX7+erKwsBg4cyOTJk5kwYQLvv/8+ubm51W47HqoRiEjtVPPLPZlGjBjBVVddxTvvvENRUREDBgzgyy+/5NZbb2Xu3Lnsu+++jBkzpsrpp2syZswYpk2bRt++fXnggQeYNWtWveItm8q6PtNYX3/99Zx66qk899xzDB48mBdeeKF8uurp06czZswYrr76ai644IJ6xZrMm9ffb2YrzeyDasoMMbMFZrbIzF5NViwikv5ycnIYOnQoY8eOLa8NbNy4kZYtW9KqVStWrFjB888/X+02jjvuOKZNm8aWLVvYtGkTzzzzTPm6TZs2ccABB1BcXFw+dTRAbm4umzZt2m1bhx56KEuWLOGzzz4D4J///CfHH398nb5bqqerTmaN4AHgDqDSuyuYWWvgLmCYu39lZvslMRYR2QOMGjWKM888s7yJqGza5sMOO4zOnTszePDgaj/fv39/zj33XPr27ct+++3HwIEDy9f9/ve/Z9CgQbRv355BgwaVn/zPO+88Lr74Ym6//fbyTmKAZs2aMXnyZH70ox9RUlLCwIEDufTSS+v0vcrupdynTx9atGixy3TVM2fOpEmTJvTs2ZPhw4czdepU/vSnP5GdnU1OTk5CbmCT1Gmozawb8Ky796pk3c+AA939ptpsU9NQizQ8TUOdXtJpGuoewL5mNsvM5ptZlY1cZjbOzOaZ2bxVq1Y1YIgiInu+VCaCLGAAcCpwMnCzmfWorKC7T3L3fHfPb9++fUPGKCKyx0vlqKFCYI27fwd8Z2azgb7AJymMSUSq4O6YWarDkBrUpbk/lTWCp4BjzCzLzFoAg4CPUhiPiFShWbNmrFmzpk4nGWk47s6aNWto1qxZrT6XtBqBmT0MDAHamVkhMB7IBnD3e9z9IzP7F7AQ2AHc6+5VDjUVkdTp1KkThYWFqI+u8WvWrBmdOnWq1Wd083oRkQzQWEcNiYhII6BEICKS4ZQIREQynBKBiEiGUyIQEclwSgQiIhlOiUBEJMMpEYiIZDglAhGRDKdEICKS4ZQIREQynBKBiEiGUyIQEclwSgQiIhlOiUBEJMMpEYiIZDglAhGRDKdEICKS4ZQIREQyXNISgZndb2YrzazaG9Kb2UAzKzGzkcmKRUREqpbMGsEDwLDqCphZU+D/AjOSGIeIiFQjaYnA3WcDa2sodgXwOLAyWXGIiEj1UtZHYGYdgTOBu1MVg4iIpLaz+DbgOnffUVNBMxtnZvPMbN6qVasaIDQRkcyRlcJ95wNTzQygHXCKmZW4+7SKBd19EjAJID8/3xs0ShGRPVzKEoG7dy97bWYPAM9WlgRERCS5kpYIzOxhYAjQzswKgfFANoC735Os/YqISO0kLRG4+6halB2TrDhERKR6urJYRCTDKRGIiGQ4JQIRkQynRCAikuGUCEREMpwSgYhIhlMiEBHJcEoEIiIZTolARCTDKRGIiGQ4JQIRkQynRCAikuGUCEREMpwSgYhIhlMiEBHJcEoEIiIZTolARCTDKRGIiGQ4JQIRkQynRCAikuGSlgjM7H4zW2lmH1SxfrSZLTSz983sDTPrm6xYRESkasmsETwADKtm/ZfA8e7eG/g9MCmJsYiISBWykrVhd59tZt2qWf9GzNu3gE7JikVERKrWWPoIfgo8X9VKMxtnZvPMbN6qVasaMCwRkT1fyhOBmQ0lJILrqirj7pPcPd/d89u3b99wwYmIZICkNQ3Fw8z6APcCw919TSpjERHJVCmrEZhZF+AJ4Hx3/yRVcYiIZLqk1QjM7GFgCNDOzAqB8UA2gLvfA/wWaAvcZWYAJe6en6x4RESkcskcNTSqhvUXARcla/8iIhKflHcWi4hIaikRiIhkOCUCEZEMp0QgIpLh4koEZtbSzJpEr3uY2elmlp3c0EREpCHEWyOYDTQzs47ADOB8wqRyIiKS5uJNBObuRcBZwF3u/iOgZ/LCEhGRhhJ3IjCzo4DRwPRoWdPkhCQiIg0p3kTwS+AG4El3X2RmBwEzkxeWiIg0lLiuLHb3V4FXAaJO49XufmUyAxMRkYYR76ihh8xsHzNrCXwAfGhmv05uaCIi0hDibRo63N03AmcQbiDTnTBySERE0ly8iSA7um7gDOBpdy8GPHlhiYhIQ4k3EfwNWAK0BGabWVdgY7KCEhGRhhNvZ/HtwO0xi5ZGt5gUEZE0F29ncSsz+0vZDeTN7M+E2oGIiKS5eJuG7gc2AedEj43A5GQFJSIiDSfeO5R9z93Pjnn/OzNbkIyARESkYcVbI9hiZseUvTGzwcCW5IQkIiINKd4awaXAP8ysVfR+HXBhdR8ws/uB04CV7t6rkvUG/BU4BSgCxrj7O/EGLiIiiRFXjcDd33P3vkAfoI+75wEn1PCxB4Bh1awfDhwSPcYBd8cTi4iIJFat7lDm7hujK4wBrq6h7GxgbTVFRgD/8OAtoLWZHVCbeEREpP7qc6tKq+e+OwJfx7wvjJbtviOzcWVDV1etWlXP3YqISKz6JIIGm2LC3Se5e76757dv376hdisikhGq7Sw2s01UfsI3oHk9970M6BzzvlO0TEREGlC1icDdc5O476eBy81sKjAI2ODuy5O4PxERqUS8w0drzcweBoYA7cysEBgPZAO4+z3Ac4Sho58Rho/+JFmxiIhI1ZKWCNx9VA3rHfh5svYvIiLxqU9nsYiI7AGUCEREMpwSgYhIhlMiEBHJcEoEIiIZTolARCTDKRGIiGQ4JQIRkQynRCAikuGUCEREMpwSgYhIhlMiEBHJcEoEIiIZTolARCTDKRGIiGQ4JQIRkQynRCAikuGUCEREMpwSgYhIhktqIjCzYWb2sZl9ZmbXV7K+i5nNNLN3zWyhmZ2SzHhERGR3SUsEZtYUuBMYDhwOjDKzwysUuwl41N3zgPOAu5IVj4iIVC6ZNYIjgM/c/Qt33w5MBUZUKOPAPtHrVsA3SYxHREQqkZXEbXcEvo55XwgMqlBmAjDDzK4AWgInJTEeERGpRKo7i0cBD7h7J+AU4J9mtltMZjbOzOaZ2bxVq1Y1eJAiInuyZCaCZUDnmPedomWxfgo8CuDubwLNgHYVN+Tuk9w9393z27dvn6RwRUQyUzITwVzgEDPrbmZ7ETqDn65Q5ivgRAAz+z4hEegnv4hIA0paInD3EuBy4AXgI8LooEVmdouZnR4V+xVwsZm9BzwMjHF3T1ZMIiKyu2R2FuPuzwHPVVj225jXHwKDkxmDiIhUL9WdxSIikmJKBCIiGU6JQEQkwykRiIhkOCUCEZEMp0QgIpLhlAhERDKcEoGISIZTIhARyXBKBCIiGU6JQEQkwykRiIhkOCUCEZEMp0QgIpLhlAhERDKcEkGMggLo1g2aNAnPBQWpjkhEJPmSemOadFJQAOPGQVFReL90aXgPMHp06uISEUk21QgiN964MwmUKSoKy+tCtQsRSRdKBJGvvqrd8uqU1S6WLgX3nbWLiskg3mShpCIiyaREEOnSJb7l8ZyU46ld1CZZxFNORKSukpoIzGyYmX1sZp+Z2fVVlDnHzD40s0Vm9lAy46nOxInQosWuy1q0CMvLxHtSjqd2EW9TVKKbrEREKkpaIjCzpsCdwHDgcGCUmR1eocwhwA3AYHfvCfwyWfHUZPRomDQJunYFs/A8adKuHcXxnpTjqV3E2xSVyCYr2ZWa3ESCZNYIjgA+c/cv3H07MBUYUaHMxcCd7r4OwN1XJjGeGo0eDUuWwI4d4bniaKF4T8rx1C7ibYpKZJNVMsqlKzW5icRw96Q8gJHAvTHvzwfuqFBmGvBH4HXgLWBYFdsaB8wD5nXp0sVTYscOHzpgsV81/M/+4g0n+pK/dvFzj3zYwb1r192LT5kSlpuF5ylTdl/fooV7OA2FR4sWdSuXyG3Vplw669p11+9X9qjsbymyJwDmeVXn66pW1PcRZyJ4FngSyAa6A18Dravb7oABA5J3pCoq2eK+7Hn3uVe4P3WQewHuBfj7f+jp8/8rz70A/58LrvGCKcV12nxNySLecvGe1BJdLt74GyOzyr+jWaojE0mOVCWCo4AXYt7fANxQocw9wE9i3r8MDKxuu0lNBDt2uG/8zP2Tu91n/dB9aotw8p/a3H3mqe6f3OVPTvnSu3Z13ytrmz94xc/C+pdPct+6Onlx1SDek1oiy9Wm1tDQCSOe/alGIJkmVYkgC/gi+qW/F/Ae0LNCmWHAg9HrdlGNoG11201oIij6xv3rp9wX3OT+ysnu/9um/Fe/T+vm/vbP3Zc9515cVPU2PrvP/eG9Qvm17yYutlpIRY2gNrWGeJujTjt6rh932Kv1ShZq/hKpXEoSQdgvpwCfAJ8DN0bLbgFOj14b8BfgQ+B94LyatlnnRLB9g/vyF90/mOj+6hnuT3TcedJ/qKn79D7ub13k/unf3Nd/GGoH8Vr177C9qc3dvyyoW3z1kIo+gnhrF/EkjClT3Ht3+8Q33JvrRZOb+cEdPqnzSbk2v/TTuWlLpLZSlgiS8ahzIvhiys4T/9OHuM/5sftH/+O+co578Xd122asom/dZxwbtj//avfSuvUb1FWi+hviLRfvCTeehNHje1v8nYn9fPU9bXzdpFY+66bj3Ky0Ts00avsXqZwSgbv7lpXu38xw37a2bp+PR+n20LFcgPtLJ7hvWZW8faVYvLWLeBLGPWMvcS/AT+n3rI89/l73AvzSE++q9OSdqAQlkmmUCBra5w+4P7y3+7SuoTlqR2mqI0qKeGoXNSaMLx9yL8D/cN610fodPuP6k3zjvTl+dN8ltdtWnGX2BGrWktpSIkiF1XPdn+wcagdPdHSf90v3VW/Wru9hD1HlSWvDYvdHcnzFlMG+T+72nb/e233pm+5r6cumnLzL8UrFsNZEN7klYp+ZkuwksZQIUqV4c/jF++qIMLKobDTSO9e6r5mfkUmhXPF37tN7uz/W1v27r3c7+b095f+F4/X55PKPNHT7fzI64etdg3I1f0ndKBE0BtvWhyajV4a7P5QVTnJPHRyGrq6ZHzqbizdnTnJ466JwDJY9V/n6HaXuM45xf7R1GObrDX8CTORw20T2qdQmIaaidiSJl4hjX10isLA+feTn5/u8efNSHUb9bFsDXz8JS6fCypngO3ausyaQlQNZuZBd9pwbnrNyotc50eucmNdl6/eB5h2h+f5hW43Rl1PgzfPh8Bug339XXW7jJ/B8XzhgGBz7BAUP2S53kYMwh1PFyQEBKN0Gm7+Aks3R4zso3hzzPlrmpXDIpZBz0G67b9IknGIrMgvzUdWmXLduYT6jirp2DfNaJWNbFe+6B9Ucrxokclu12eeNN4a5vLp0CXN1ZeLdAhN17M1svrvnV7pOiSDFtqyAFa/A9nVQsik6WW2C4k0xz5t3PseexKrTJBtadIaWXaFFl/DcskvM+27QdK8G+Yq72PAR/Csf2ubDCS9DkxrulvrhH2HBdTD4Eeh6Tnwnh+Uz4O1x8F0lZ8tYTbLDWTerBRwxCbqeu8vqeE+48ZSLN6nEs614Twzxxh+PRG4rHqlIPI1Voo59dYkg5U09tX2kbdNQou0odd++yb1oufvGT8NVzStecy98xv2Tu9zfvd59zij3F452f7KT+0NNdl5HUTZtxksnui+8xX3FbPeSrcmPuXiz+7M93R9r7/7dsvg+U1rs/vyA8JmahuNuXeP+5pjw/Z45NDTFFT7j/u3M0Hm//iP3zV+FIcQl28JnNi8Jx6iA0FwVc01JIvsIknEldk1NBfE2ITX0tuIp15j7QRq6iSxRfWOoj0C8dLv7pi/dv53l/vmD7nOvDFdTlyeGZu4vDXVfOCGcOEu2JD6GN8e4F5j7Ny/U7nPrFro/nB0uAqzK0sfcH+8QrhJ/94baxV9a7L7gNyG2Zw8P+4sk6sSWirmZGrrvIhVXrifyeMUjlX/H/fb51rOabq/02MdDiUCqtnW1+1dPhuGtz+WFk2EB4SuRdPEAAA4pSURBVDqIGYPd55znPvfykCA+vsN9yVT35S+5r13g/l1h/DWJzyeH7S64qW5xvjc+fP7rp3ddXrTcffbZYd1z/dzXvFO37buHaz4e7xCS4if3JLzjPhWT7zVkTaWxz2XVkDWVRA7xnTLFfXj/l335nR38/5x7XZ23pUQg8du2Npxs5/8qJIKnDg4jd2KblSo+HsoKiWNqC/dHckP5x9q6P76f+xMHhKaph7PdXxziXlpSt7hKtrk/28v9iQPdt60LJ+nPJ7v/775h3x/8d6j11FfRt2ECwgLcZ48M+0pjNZ3YEvnLOxWz2zbWmkrCrnkpLXFf+DvfMcX8k//5vvfs9IFGDcEe2FmcLnYUw7a1sG11hccqKCkCL63+kdUSet4EzTvUPYY1c2HGkdB5JBRvgOUvQPvBcMS90OqwxH1X3wEf/Rne+w206AiDp0K7IxO3/UYkFR3KtRn1VNPAgESOsoqnXCJHf9XYIb51JbwxGr59CbqdD0fcHf4f1ZFGDcme491r4aM/hf8Qff8APX6WvGGyq9+C10dB0ddw0E+g+YGwV2vIbg17tYqeW0N2q/CclQs7toYRXsUbo5FeG2PebwwjwZo0g337QOu+0Kx9cmKPUyqGmCZyn4kcsdWkCWQ33cY1p97KZysO5sm5Z1JculftTt61iKvaMv9+Fd4YFUYT5t8BB40NAddDdYmghrF7Io1Mn1ug+QHQ6UzI6ZbcfbU7Eoa/C/Muh6WPhJN4ojU/AFr3g337hsSwb1/IPaTmYbUJUnbySsR4/Xi3lch9TpxY+Ym54v3BKzvhVrzvd973V/LXkWdxzKGvA/Dt+g7cN+unTP/4EqBLrWKPJ67K7oFutoPR/f4Ar9wMOQfDkH+FHw1JphqBSLx2lIZksH09FK+H7Rt2fS7eCE2bRxf37ROes2Oes6Ln4o2w/j1YFz3WvwcbPwrNbwBNm0Gr3nDAf0CnM6DNgHr/GtyT1dSEFNev+PXvs3n6D2lavIKf/G0y64ta87OT7uLUvOmYQZNOp8IhPwt/kzhroDXFVbFG0C53Ff+87HyG9X0Buo6CI/4W/u0kiJqGRBq70u0hGZQlhrXzYNXroX+lRSfoOAI6nwH7HR8uhJNaqfakvOzZ0ASYncvzRU9x2Y0Dy8v9z8SvOLPXJPj876HNPucgOPiS0FTTrF29YypLUIN7zGHqFefRLnc172X9lUE/Hpfw5K9EIJKOtq2BZdOhcBos/xeUbgn9Eh1PDU1jB5wcphmRunGHxX+Bd38N++bB8U+HwQGVKd0OhU/Cp3fBytnQZG/ofgEM+CtkNa9zCAUF8OFT9/C7H17O1+u681HbRzlldF6dt1cdJQKRdFdSFEaPFE6DZU+HJNFkb9jvOGg7CNoODI/mB8S/TXf47ktY+y6sezeMlur2Y2jdK3nfo7Eo3Q5zL4Mv7g+j0I56MEw1Eo/1i0JC+PRu2O9YOO7pMHigLsqmUDnwVBj8UGg6TBIlApE9yY6S0GxU+CSsmAkbFoUmJAgTDrYdCG2PCM9t8sOIph0loemp7KS/7l1YtyAMwwWwpoCBl4TPHDQmtFPv3SZV3zJ5tq6GOWeHX/a9bobeE+o28mzJ1DB5Yus+MPRftRsB5g4Lb4ZFE6HreXDUP5Le5JeyRGBmw4C/Ak2Be939D1WUOxt4DBjo7tWe5ZUIRCooKQon9jVzw2PtXNj06c71LbvClm9hx7bwvmnzcPLaNw/a5IXnVr3CZIZLHoIvJod+iiZ7QacR0H1M6CRN1Eim4s2wdUW4DqVVz4Zt3trwIcw6DbZ8A0feH2pA9bHsOZgzMkzoOHRGeK6J74D5V8Ent8P3LoKB90CTpvWLIw4pSQRm1hT4BPgBUAjMBUa5+4cVyuUC04G9gMuVCEQSYPs6WDs/JIb1C0NNoezEn9uj5pP6ugXwxQOwpCCcsJsfEC5q6n5BmOK8dAuUbAnXTZRsCe/LH1tDTWPrivDY8m30OnqOnTm3aYswMqr7f8L+P0jOsNkdJaHzffmLsPjWkAiPewraDUrM9lfOgVdPC806J7wI+xxaTSylYWbcL+6HQ6+C/n9usBFhqUoERwET3P3k6P0NAO7+fyqUuw14Efg1cI0SgUgjUrodvpkeksI303c2QcVr73bQrAM02z88N99/5/vs3HB1+FePhsS1d/vQTNLtP0OzVl1PkO7hl/+Kl0O/yspXw5BdLPSpHPVPaNm5btuuyroFMPPk8Gt/6AvQpv/uZUq3h6akrx6FXr+NmqQablhwqhLBSGCYu18UvT8fGOTul8eU6Q/c6O5nm9ksqkgEZjYOGAfQpUuXAUsruzpERJJry4rQWb1jW/hVXf5otvN1Vtlzbmgzj6fdu3RbGBX15RRY9kzYfs7BoZbQbTTkHrz7Z3aUhnLlNZBNsOatcOL/9uVQ+wDI+R7sfxLsfyLsN7TeQz6rtfFTmPmDMBXL8c9Ah+N3rivZAnN+FJJp3p/g+9ckL44qNMpEYGZNgFeAMe6+pLpEEEs1ApE92PYN8PXjoUlqxUzAw02UvDSc8Eu3huaosovvKtq7fTjp738SdDgx+VefV1RUCK/8RxiNdcz/QsfTQp/I7NNhxSwYeDcccknDxhRJ1RQTy4DY+lenaFmZXKAXMMtC9Wh/4GkzO72mZCAie6i9WsH3xoZHUSEseTh0hDdtFh5Nmu18vcujeZiio3Wv1N6itUUnOGk2zDoFZp8R5gn64sHQgX/UP0ItpxFKZo0gi9BZfCIhAcwFfuzui6ooPwvVCERkT1C8CWaPCLWaJnuFGWw7n5nSkFJSI3D3EjO7HHiBMHz0fndfZGa3EObFfjpZ+xYRSansXBjyHLz/uzD0tsPQVEdULV1QJiKSAaqrEaSwMU1ERBoDJQIRkQynRCAikuGUCEREMpwSgYhIhlMiEBHJcEoEIiIZTolARCTDpd0FZWa2Cqhs+tF2wOoGDidR0jl2UPyplM6xQ3rHn26xd3X3Sm+jlnaJoCpmNq+qq+Yau3SOHRR/KqVz7JDe8adz7BWpaUhEJMMpEYiIZLg9KRFMSnUA9ZDOsYPiT6V0jh3SO/50jn0Xe0wfgYiI1M2eVCMQEZE6UCIQEclwaZ8IzGyYmX1sZp+Z2fWpjqe2zGyJmb1vZgvMrNHfccfM7jezlWb2QcyyNmb2opl9Gj3vm8oYq1JF7BPMbFl0/BeY2SmpjLE6ZtbZzGaa2YdmtsjMfhEtb/THv5rY0+L4m1kzM3vbzN6L4v9dtLy7mf07Ov88YmZ7pTrWukjrPgIza0q4L/IPgELCfZFHufuHKQ2sFsxsCZDv7mlxYYqZHQdsBv7h7r2iZX8E1rr7H6JkvK+7X5fKOCtTRewTgM3ufmsqY4uHmR0AHODu75hZLjAfOAMYQyM//tXEfg5pcPzNzICW7r7ZzLKBOcAvgKuBJ9x9qpndA7zn7nenMta6SPcawRHAZ+7+hbtvB6YCI1Ic0x7N3WcDayssHgE8GL1+kPAfvNGpIva04e7L3f2d6PUm4COgI2lw/KuJPS14sDl6mx09HDgBeCxa3iiPfTzSPRF0BL6OeV9IGv3jijgww8zmm9m4VAdTRx3cfXn0+lugQyqDqYPLzWxh1HTU6JpVKmNm3YA84N+k2fGvEDukyfE3s6ZmtgBYCbwIfA6sd/eSqEg6nn+A9E8Ee4Jj3L0/MBz4edR8kbY8tDWmU3vj3cD3gH7AcuDPqQ2nZmaWAzwO/NLdN8aua+zHv5LY0+b4u3upu/cDOhFaIw5LcUgJk+6JYBnQOeZ9p2hZ2nD3ZdHzSuBJwj+wdLMiagMuawtemeJ44ubuK6L/4DuAv9PIj3/UPv04UODuT0SL0+L4VxZ7uh1/AHdfD8wEjgJam1lWtCrtzj9l0j0RzAUOiXru9wLOA55OcUxxM7OWUccZZtYS+A/gg+o/1Sg9DVwYvb4QeCqFsdRK2Qk0ciaN+PhHHZb3AR+5+19iVjX6419V7Oly/M2svZm1jl43JwxQ+YiQEEZGxRrlsY9HWo8aAoiGm90GNAXud/eJKQ4pbmZ2EKEWAJAFPNTY4zezh4EhhCl4VwDjgWnAo0AXwhTh57h7o+uUrSL2IYRmCQeWAJfEtLc3KmZ2DPAa8D6wI1r8G0Jbe6M+/tXEPoo0OP5m1ofQGdyU8AP6UXe/Jfo/PBVoA7wL/Ke7b0tdpHWT9olARETqJ92bhkREpJ6UCEREMpwSgYhIhlMiEBHJcEoEIiIZTolAJGJmpTGzYC5I5Gy2ZtYtdtZTkcYkq+YiIhljSzSFgEhGUY1ApAbRPSP+GN034m0zOzha3s3MXokmTHvZzLpEyzuY2ZPR3PXvmdnR0aaamtnfo/nsZ0RXqGJmV0bz9C80s6kp+pqSwZQIRHZqXqFp6NyYdRvcvTdwB+FKdoD/Bzzo7n2AAuD2aPntwKvu3hfoDyyKlh8C3OnuPYH1wNnR8uuBvGg7lybry4lURVcWi0TMbLO751SyfAlwgrt/EU2c9q27tzWz1YSbrRRHy5e7ezszWwV0ip1qIJp6+UV3PyR6fx2Q7e7/ZWb/ItwwZxowLWbee5EGoRqBSHy8ite1ETsHTSk7++hOBe4k1B7mxsxmKdIglAhE4nNuzPOb0es3CDPeAowmTKoG8DJwGZTfzKRVVRs1syZAZ3efCVwHtAJ2q5WIJJN+eYjs1Dy6A1WZf7l72RDSfc1sIeFX/aho2RXAZDP7NbAK+Em0/BfAJDP7KeGX/2WEm65UpikwJUoWBtwezXcv0mDURyBSg6iPIN/dV6c6FpFkUNOQiEiGU41ARCTDqUYgIpLhlAhERDKcEoGISIZTIhARyXBKBCIiGe7/A/CfZW9O/oW3AAAAAElFTkSuQmCC\n",
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ]
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Learning curve(accuracy)\n",
        "# the training and validation accuracy by epoch\n",
        "\n",
        "# accuracy\n",
        "acc = history.history['accuracy']\n",
        "val_acc = history.history['val_accuracy']\n",
        "\n",
        "# range of X (no. of epochs)\n",
        "epochs = range(1, len(acc) + 1)\n",
        "\n",
        "# plot\n",
        "# \"bo\" is for \"blue dot\"\n",
        "plt.plot(epochs, acc, 'bo', label='Training accuracy')\n",
        "# orange is for \"orange\"\n",
        "plt.plot(epochs, val_acc, 'orange', label='Validation accuracy')\n",
        "plt.title('Training and validation accuracy')\n",
        "plt.xlabel('Epochs')\n",
        "plt.ylabel('Accuracy')\n",
        "plt.legend()\n",
        "plt.show()\n",
        "\n",
        "# this is the max value - should correspond to\n",
        "# the HIGHEST train accuracy\n",
        "np.max(val_acc)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 313
        },
        "id": "VYWd7lpldhgE",
        "outputId": "af67d62a-d9d5-421c-f081-0ef35d156342"
      },
      "execution_count": 32,
      "outputs": [
        {
          "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": "execute_result",
          "data": {
            "text/plain": [
              "0.8483145833015442"
            ]
          },
          "metadata": {},
          "execution_count": 32
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "from sklearn.metrics import confusion_matrix\n",
        "from sklearn.metrics import classification_report\n",
        "\n",
        "# see how these are numbers between 0 and 1? \n",
        "model.predict(X) # prob of successes (survival)\n",
        "np.round(model.predict(X),0) # 1 and 0 (survival or not)\n",
        "Y # 1 and 0 (survival or not)\n",
        "\n",
        "# so we need to round to a whole number (0 or 1),\n",
        "# or the confusion matrix won't work!\n",
        "preds = np.round(model.predict(X),0)\n",
        "\n",
        "# confusion matrix\n",
        "print(confusion_matrix(Y, preds)) # order matters! (actual, predicted)\n",
        "\n",
        "print(classification_report(Y, preds))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "kN6ZkIGAdmuR",
        "outputId": "d4b83744-0053-4316-a19a-58a705f084bc"
      },
      "execution_count": 33,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[[453  96]\n",
            " [ 77 263]]\n",
            "              precision    recall  f1-score   support\n",
            "\n",
            "           0       0.85      0.83      0.84       549\n",
            "           1       0.73      0.77      0.75       340\n",
            "\n",
            "    accuracy                           0.81       889\n",
            "   macro avg       0.79      0.80      0.80       889\n",
            "weighted avg       0.81      0.81      0.81       889\n",
            "\n"
          ]
        }
      ]
    }
  ]
}