diff --git a/Q_LEARNING_DATESET3.ipynb b/Q_LEARNING_DATESET3.ipynb new file mode 100644 index 0000000000000000000000000000000000000000..b6bbb376d225813de79e456c99260e20878e56a9 --- /dev/null +++ b/Q_LEARNING_DATESET3.ipynb @@ -0,0 +1,2649 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# This file implements Q-Learning for Dataset 3" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**Q-Learning and Double Q-Learning Algorithm Description**</br>\n", + "\n", + "**Q-Learning**:\n", + "\n", + "Q-learning is a reinforcement learning algorithm used to find the optimal action-selection policy for a given finite Markov decision process (MDP).\n", + "The algorithm uses a Q-table to store the expected utility of actions taken in specific states.\n", + "The agent updates the Q-values based on the rewards received and the expected future rewards (using the Bellman equation).\n", + "\n", + "**Double Q-Learning:**\n", + "\n", + "Double Q-learning addresses the overestimation bias in Q-learning by using two separate Q-tables (Q1 and Q2).\n", + "Each Q-table is updated independently, using the other Q-table to estimate the value of the next state.\n", + "\n", + "**Implementation Steps**\n", + "1.Preprocess the Data: Load and preprocess the bank dataset.</br>\n", + "\n", + "2.Implement Q-Learning: Set up and train a Q-learning model.</br>\n", + "\n", + "3.Implement Double Q-Learning: Set up and train a Double Q-learning model.</br>\n", + "\n", + "4.Evaluate the Models: Evaluate the performance of both models.</br>" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "from sklearn.preprocessing import StandardScaler\n", + "from sklearn.model_selection import train_test_split\n", + "from sklearn.metrics import accuracy_score, confusion_matrix, classification_report\n", + "import matplotlib.pyplot as plt" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "#Read dataset, check for null and duplicates\n", + "def read_dataset(dataset):\n", + " \n", + " data = pd.read_csv(dataset)\n", + " nrow = len(data.index)\n", + " ncol = len(data.columns)\n", + "\n", + " print(\"The dataset contains\", format(nrow, \",d\"), \"rows and\", ncol, \"columns.\")\n", + " \n", + " #Check for null values\n", + " if ((data.isna().sum()).sum()) > 0:\n", + " print(\"There are null items in the dataset\")\n", + " else:\n", + " print(\"There are no null items in the dataset\")\n", + " \n", + " #Check for duplicates\n", + " #(data.duplicated(subset=col_names)).sum()\n", + "\n", + " if (data.duplicated().sum()) > 0:\n", + " print(\"There are duplicates in the dataset\")\n", + " else:\n", + " print(\"There are no duplicates in the dataset\")\n", + " \n", + " return data\n", + "\n", + "\n", + "\n", + "#Function to categorize data into numeric and categorical\n", + "def categorize_data(data):\n", + " \n", + " numeric=[]\n", + " categorical=[]\n", + " numeric_dtypes = [\"int64\", \"int32\", \"float64\", \"float32\"]\n", + "\n", + " for i in range (len(data.columns)):\n", + " if data[data.columns[i]].dtype in numeric_dtypes:\n", + " numeric.append(data.columns[i])\n", + " else:\n", + " categorical.append(data.columns[i])\n", + " \n", + " return numeric, categorical\n", + "\n", + " \n", + "#Function to check for outliers\n", + "def outliers_check(data, numeric):\n", + " outliers_sum =[]\n", + "\n", + " for col in (numeric_cols):\n", + " Q1 = data[col].quantile(0.25)\n", + " Q3 = data[col].quantile(0.75)\n", + " IQR = Q3 - Q1\n", + " outliers = (data[col] < (Q1 - 10 * IQR)) | (data[col] > (Q3 + 10 * IQR))\n", + " print(col, \"\", outliers.sum())\n", + " outliers_sum.append(outliers.sum())\n", + "\n", + " return outliers.sum()\n", + "\n", + "\n", + "def remove_duplicates(data):\n", + " duplicated_sum = data.duplicated().sum()\n", + " if duplicated_sum == 0:\n", + " print(\"Number of duplicated rows in dataset =\", duplicated_sum)\n", + " return data\n", + " else:\n", + " print(\"Number of duplicated rows in dataset =\", duplicated_sum)\n", + " data = data[~data.duplicated()]\n", + " print(\"Duplicated rows have been removed\")\n", + " return data\n", + "\n", + " \n", + "def remove_outliers(data, numeric):\n", + " \n", + " for col in (numeric_cols):\n", + " median_value = np.median(data[col])\n", + " Q1 = data[col].quantile(0.25)\n", + " Q3 = data[col].quantile(0.75)\n", + " IQR = Q3 - Q1\n", + " outliers = (data[col] < (Q1 - 10 * IQR)) | (data[col] > (Q3 + 10 * IQR))\n", + " #print(col, \"\", outliers.sum())\n", + " data.loc[outliers, col] = median_value\n", + " return data\n", + "\n", + "\n", + "# remove special characters from columns\n", + "def remove_spec_chars(data, categorical_cols):\n", + " for col in categorical_cols:\n", + " data[col] = data[col].str.replace(r'\\W+', '').str.strip() #replaces special characters with white sapaces and removes the white spaces\n", + " return data\n", + "\n", + "\n", + "def replace_unknown(data, categorical_cols):\n", + " for col in categorical_cols:\n", + " if \"unknown\" in data[col].values:\n", + " #source: https://pandas.pydata.org/docs/reference/api/pandas.DataFrame.mode.html\n", + " mode = data[col].mode()[0]\n", + " data[col] = data[col].replace(\"unknown\", mode)\n", + " return data\n", + "\n", + " \n", + "def oneHotEncoding(data, categorical, drop_first):\n", + "\n", + " data_final = pd.get_dummies(data, columns=categorical, drop_first=drop_first)\n", + "\n", + " return data_final" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The dataset contains 11,162 rows and 17 columns.\n", + "There are no null items in the dataset\n", + "There are no duplicates in the dataset\n" + ] + } + ], + "source": [ + "import pandas as pd\n", + "data = read_dataset(\"bank1.csv\")" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "<div>\n", + "<style scoped>\n", + " .dataframe tbody tr th:only-of-type {\n", + " vertical-align: middle;\n", + " }\n", + "\n", + " .dataframe tbody tr th {\n", + " vertical-align: top;\n", + " }\n", + "\n", + " .dataframe thead th {\n", + " text-align: right;\n", + " }\n", + "</style>\n", + "<table border=\"1\" class=\"dataframe\">\n", + " <thead>\n", + " <tr style=\"text-align: right;\">\n", + " <th></th>\n", + " <th>age</th>\n", + " <th>job</th>\n", + " <th>marital</th>\n", + " <th>education</th>\n", + " <th>default</th>\n", + " <th>balance</th>\n", + " <th>housing</th>\n", + " <th>loan</th>\n", + " <th>contact</th>\n", + " <th>day</th>\n", + " <th>month</th>\n", + " <th>duration</th>\n", + " <th>campaign</th>\n", + " <th>pdays</th>\n", + " <th>previous</th>\n", + " <th>poutcome</th>\n", + " <th>deposit</th>\n", + " </tr>\n", + " </thead>\n", + " <tbody>\n", + " <tr>\n", + " <th>0</th>\n", + " <td>59</td>\n", + " <td>admin.</td>\n", + " <td>married</td>\n", + " <td>secondary</td>\n", + " <td>no</td>\n", + " <td>2343</td>\n", + " <td>yes</td>\n", + " <td>no</td>\n", + " <td>unknown</td>\n", + " <td>5</td>\n", + " <td>may</td>\n", + " <td>1042</td>\n", + " <td>1</td>\n", + " <td>-1</td>\n", + " <td>0</td>\n", + " <td>unknown</td>\n", + " <td>yes</td>\n", + " </tr>\n", + " <tr>\n", + " <th>1</th>\n", + " <td>56</td>\n", + " <td>admin.</td>\n", + " <td>married</td>\n", + " <td>secondary</td>\n", + " <td>no</td>\n", + " <td>45</td>\n", + " <td>no</td>\n", + " <td>no</td>\n", + " <td>unknown</td>\n", + " <td>5</td>\n", + " <td>may</td>\n", + " <td>1467</td>\n", + " <td>1</td>\n", + " <td>-1</td>\n", + " <td>0</td>\n", + " <td>unknown</td>\n", + " <td>yes</td>\n", + " </tr>\n", + " <tr>\n", + " <th>2</th>\n", + " <td>41</td>\n", + " <td>technician</td>\n", + " <td>married</td>\n", + " <td>secondary</td>\n", + " <td>no</td>\n", + " <td>1270</td>\n", + " <td>yes</td>\n", + " <td>no</td>\n", + " <td>unknown</td>\n", + " <td>5</td>\n", + " <td>may</td>\n", + " <td>1389</td>\n", + " <td>1</td>\n", + " <td>-1</td>\n", + " <td>0</td>\n", + " <td>unknown</td>\n", + " <td>yes</td>\n", + " </tr>\n", + " <tr>\n", + " <th>3</th>\n", + " <td>55</td>\n", + " <td>services</td>\n", + " <td>married</td>\n", + " <td>secondary</td>\n", + " <td>no</td>\n", + " <td>2476</td>\n", + " <td>yes</td>\n", + " <td>no</td>\n", + " <td>unknown</td>\n", + " <td>5</td>\n", + " <td>may</td>\n", + " <td>579</td>\n", + " <td>1</td>\n", + " <td>-1</td>\n", + " <td>0</td>\n", + " <td>unknown</td>\n", + " <td>yes</td>\n", + " </tr>\n", + " <tr>\n", + " <th>4</th>\n", + " <td>54</td>\n", + " <td>admin.</td>\n", + " <td>married</td>\n", + " <td>tertiary</td>\n", + " <td>no</td>\n", + " <td>184</td>\n", + " <td>no</td>\n", + " <td>no</td>\n", + " <td>unknown</td>\n", + " <td>5</td>\n", + " <td>may</td>\n", + " <td>673</td>\n", + " <td>2</td>\n", + " <td>-1</td>\n", + " <td>0</td>\n", + " <td>unknown</td>\n", + " <td>yes</td>\n", + " </tr>\n", + " </tbody>\n", + "</table>\n", + "</div>" + ], + "text/plain": [ + " age job marital education default balance housing loan contact \\\n", + "0 59 admin. married secondary no 2343 yes no unknown \n", + "1 56 admin. married secondary no 45 no no unknown \n", + "2 41 technician married secondary no 1270 yes no unknown \n", + "3 55 services married secondary no 2476 yes no unknown \n", + "4 54 admin. married tertiary no 184 no no unknown \n", + "\n", + " day month duration campaign pdays previous poutcome deposit \n", + "0 5 may 1042 1 -1 0 unknown yes \n", + "1 5 may 1467 1 -1 0 unknown yes \n", + "2 5 may 1389 1 -1 0 unknown yes \n", + "3 5 may 579 1 -1 0 unknown yes \n", + "4 5 may 673 2 -1 0 unknown yes " + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "pd.set_option('display.max_columns', None)\n", + "\n", + "(data).head()" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "<class 'pandas.core.frame.DataFrame'>\n", + "RangeIndex: 11162 entries, 0 to 11161\n", + "Data columns (total 17 columns):\n", + " # Column Non-Null Count Dtype \n", + "--- ------ -------------- ----- \n", + " 0 age 11162 non-null int64 \n", + " 1 job 11162 non-null object\n", + " 2 marital 11162 non-null object\n", + " 3 education 11162 non-null object\n", + " 4 default 11162 non-null object\n", + " 5 balance 11162 non-null int64 \n", + " 6 housing 11162 non-null object\n", + " 7 loan 11162 non-null object\n", + " 8 contact 11162 non-null object\n", + " 9 day 11162 non-null int64 \n", + " 10 month 11162 non-null object\n", + " 11 duration 11162 non-null int64 \n", + " 12 campaign 11162 non-null int64 \n", + " 13 pdays 11162 non-null int64 \n", + " 14 previous 11162 non-null int64 \n", + " 15 poutcome 11162 non-null object\n", + " 16 deposit 11162 non-null object\n", + "dtypes: int64(7), object(10)\n", + "memory usage: 1.4+ MB\n" + ] + } + ], + "source": [ + "data.info()" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "<div>\n", + "<style scoped>\n", + " .dataframe tbody tr th:only-of-type {\n", + " vertical-align: middle;\n", + " }\n", + "\n", + " .dataframe tbody tr th {\n", + " vertical-align: top;\n", + " }\n", + "\n", + " .dataframe thead th {\n", + " text-align: right;\n", + " }\n", + "</style>\n", + "<table border=\"1\" class=\"dataframe\">\n", + " <thead>\n", + " <tr style=\"text-align: right;\">\n", + " <th></th>\n", + " <th>age</th>\n", + " <th>balance</th>\n", + " <th>day</th>\n", + " <th>duration</th>\n", + " <th>campaign</th>\n", + " <th>pdays</th>\n", + " <th>previous</th>\n", + " </tr>\n", + " </thead>\n", + " <tbody>\n", + " <tr>\n", + " <th>count</th>\n", + " <td>11162.000000</td>\n", + " <td>11162.000000</td>\n", + " <td>11162.000000</td>\n", + " <td>11162.000000</td>\n", + " <td>11162.000000</td>\n", + " <td>11162.000000</td>\n", + " <td>11162.000000</td>\n", + " </tr>\n", + " <tr>\n", + " <th>mean</th>\n", + " <td>41.231948</td>\n", + " <td>1528.538524</td>\n", + " <td>15.658036</td>\n", + " <td>371.993818</td>\n", + " <td>2.508421</td>\n", + " <td>51.330407</td>\n", + " <td>0.832557</td>\n", + " </tr>\n", + " <tr>\n", + " <th>std</th>\n", + " <td>11.913369</td>\n", + " <td>3225.413326</td>\n", + " <td>8.420740</td>\n", + " <td>347.128386</td>\n", + " <td>2.722077</td>\n", + " <td>108.758282</td>\n", + " <td>2.292007</td>\n", + " </tr>\n", + " <tr>\n", + " <th>min</th>\n", + " <td>18.000000</td>\n", + " <td>-6847.000000</td>\n", + " <td>1.000000</td>\n", + " <td>2.000000</td>\n", + " <td>1.000000</td>\n", + " <td>-1.000000</td>\n", + " <td>0.000000</td>\n", + " </tr>\n", + " <tr>\n", + " <th>25%</th>\n", + " <td>32.000000</td>\n", + " <td>122.000000</td>\n", + " <td>8.000000</td>\n", + " <td>138.000000</td>\n", + " <td>1.000000</td>\n", + " <td>-1.000000</td>\n", + " <td>0.000000</td>\n", + " </tr>\n", + " <tr>\n", + " <th>50%</th>\n", + " <td>39.000000</td>\n", + " <td>550.000000</td>\n", + " <td>15.000000</td>\n", + " <td>255.000000</td>\n", + " <td>2.000000</td>\n", + " <td>-1.000000</td>\n", + " <td>0.000000</td>\n", + " </tr>\n", + " <tr>\n", + " <th>75%</th>\n", + " <td>49.000000</td>\n", + " <td>1708.000000</td>\n", + " <td>22.000000</td>\n", + " <td>496.000000</td>\n", + " <td>3.000000</td>\n", + " <td>20.750000</td>\n", + " <td>1.000000</td>\n", + " </tr>\n", + " <tr>\n", + " <th>max</th>\n", + " <td>95.000000</td>\n", + " <td>81204.000000</td>\n", + " <td>31.000000</td>\n", + " <td>3881.000000</td>\n", + " <td>63.000000</td>\n", + " <td>854.000000</td>\n", + " <td>58.000000</td>\n", + " </tr>\n", + " </tbody>\n", + "</table>\n", + "</div>" + ], + "text/plain": [ + " age balance day duration campaign \\\n", + "count 11162.000000 11162.000000 11162.000000 11162.000000 11162.000000 \n", + "mean 41.231948 1528.538524 15.658036 371.993818 2.508421 \n", + "std 11.913369 3225.413326 8.420740 347.128386 2.722077 \n", + "min 18.000000 -6847.000000 1.000000 2.000000 1.000000 \n", + "25% 32.000000 122.000000 8.000000 138.000000 1.000000 \n", + "50% 39.000000 550.000000 15.000000 255.000000 2.000000 \n", + "75% 49.000000 1708.000000 22.000000 496.000000 3.000000 \n", + "max 95.000000 81204.000000 31.000000 3881.000000 63.000000 \n", + "\n", + " pdays previous \n", + "count 11162.000000 11162.000000 \n", + "mean 51.330407 0.832557 \n", + "std 108.758282 2.292007 \n", + "min -1.000000 0.000000 \n", + "25% -1.000000 0.000000 \n", + "50% -1.000000 0.000000 \n", + "75% 20.750000 1.000000 \n", + "max 854.000000 58.000000 " + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "#Summary statistics of the dataset\n", + "data.describe()" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "no 5873\n", + "yes 5289\n", + "Name: deposit, dtype: int64" + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "#Class imbalance\n", + "data['deposit'].value_counts()" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "7 numeric columns and 10 categorical columns\n" + ] + } + ], + "source": [ + "#Categorize data into numeric and categorical\n", + "numeric_cols, categorical_cols = categorize_data(data)\n", + "\n", + "print(f\"{len(numeric_cols)} numeric columns and {len(categorical_cols)} categorical columns\")" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "age 0\n", + "balance 74\n", + "day 0\n", + "duration 0\n", + "campaign 27\n", + "pdays 917\n", + "previous 73\n" + ] + } + ], + "source": [ + "#Check for outliers\n", + "outliers = outliers_check(data, numeric_cols)" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "<Figure size 1008x720 with 2 Axes>" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "import seaborn as sns\n", + "import matplotlib.pyplot as plt\n", + "\n", + "# Convert categorical variables to numerical using one-hot encoding\n", + "data_encoded = pd.get_dummies(data)\n", + "\n", + "# Calculate the correlation matrix\n", + "corr = data_encoded.corr()\n", + "\n", + "# Create a heatmap\n", + "plt.figure(figsize=(14, 10))\n", + "sns.heatmap(corr, annot=False, cmap='coolwarm', fmt='.2f', linewidths=0.5)\n", + "plt.title('Heatmap of Correlation Matrix')\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "<div>\n", + "<style scoped>\n", + " .dataframe tbody tr th:only-of-type {\n", + " vertical-align: middle;\n", + " }\n", + "\n", + " .dataframe tbody tr th {\n", + " vertical-align: top;\n", + " }\n", + "\n", + " .dataframe thead th {\n", + " text-align: right;\n", + " }\n", + "</style>\n", + "<table border=\"1\" class=\"dataframe\">\n", + " <thead>\n", + " <tr style=\"text-align: right;\">\n", + " <th></th>\n", + " <th>age</th>\n", + " <th>job</th>\n", + " <th>marital</th>\n", + " <th>education</th>\n", + " <th>default</th>\n", + " <th>balance</th>\n", + " <th>housing</th>\n", + " <th>loan</th>\n", + " <th>contact</th>\n", + " <th>day</th>\n", + " <th>month</th>\n", + " <th>duration</th>\n", + " <th>campaign</th>\n", + " <th>pdays</th>\n", + " <th>previous</th>\n", + " <th>poutcome</th>\n", + " <th>deposit</th>\n", + " </tr>\n", + " </thead>\n", + " <tbody>\n", + " <tr>\n", + " <th>0</th>\n", + " <td>59</td>\n", + " <td>admin.</td>\n", + " <td>married</td>\n", + " <td>secondary</td>\n", + " <td>no</td>\n", + " <td>2343</td>\n", + " <td>yes</td>\n", + " <td>no</td>\n", + " <td>unknown</td>\n", + " <td>5</td>\n", + " <td>may</td>\n", + " <td>1042</td>\n", + " <td>1</td>\n", + " <td>-1</td>\n", + " <td>0</td>\n", + " <td>unknown</td>\n", + " <td>yes</td>\n", + " </tr>\n", + " <tr>\n", + " <th>1</th>\n", + " <td>56</td>\n", + " <td>admin.</td>\n", + " <td>married</td>\n", + " <td>secondary</td>\n", + " <td>no</td>\n", + " <td>45</td>\n", + " <td>no</td>\n", + " <td>no</td>\n", + " <td>unknown</td>\n", + " <td>5</td>\n", + " <td>may</td>\n", + " <td>1467</td>\n", + " <td>1</td>\n", + " <td>-1</td>\n", + " <td>0</td>\n", + " <td>unknown</td>\n", + " <td>yes</td>\n", + " </tr>\n", + " <tr>\n", + " <th>2</th>\n", + " <td>41</td>\n", + " <td>technician</td>\n", + " <td>married</td>\n", + " <td>secondary</td>\n", + " <td>no</td>\n", + " <td>1270</td>\n", + " <td>yes</td>\n", + " <td>no</td>\n", + " <td>unknown</td>\n", + " <td>5</td>\n", + " <td>may</td>\n", + " <td>1389</td>\n", + " <td>1</td>\n", + " <td>-1</td>\n", + " <td>0</td>\n", + " <td>unknown</td>\n", + " <td>yes</td>\n", + " </tr>\n", + " <tr>\n", + " <th>3</th>\n", + " <td>55</td>\n", + " <td>services</td>\n", + " <td>married</td>\n", + " <td>secondary</td>\n", + " <td>no</td>\n", + " <td>2476</td>\n", + " <td>yes</td>\n", + " <td>no</td>\n", + " <td>unknown</td>\n", + " <td>5</td>\n", + " <td>may</td>\n", + " <td>579</td>\n", + " <td>1</td>\n", + " <td>-1</td>\n", + " <td>0</td>\n", + " <td>unknown</td>\n", + " <td>yes</td>\n", + " </tr>\n", + " <tr>\n", + " <th>4</th>\n", + " <td>54</td>\n", + " <td>admin.</td>\n", + " <td>married</td>\n", + " <td>tertiary</td>\n", + " <td>no</td>\n", + " <td>184</td>\n", + " <td>no</td>\n", + " <td>no</td>\n", + " <td>unknown</td>\n", + " <td>5</td>\n", + " <td>may</td>\n", + " <td>673</td>\n", + " <td>2</td>\n", + " <td>-1</td>\n", + " <td>0</td>\n", + " <td>unknown</td>\n", + " <td>yes</td>\n", + " </tr>\n", + " <tr>\n", + " <th>...</th>\n", + " <td>...</td>\n", + " <td>...</td>\n", + " <td>...</td>\n", + " <td>...</td>\n", + " <td>...</td>\n", + " <td>...</td>\n", + " <td>...</td>\n", + " <td>...</td>\n", + " <td>...</td>\n", + " <td>...</td>\n", + " <td>...</td>\n", + " <td>...</td>\n", + " <td>...</td>\n", + " <td>...</td>\n", + " <td>...</td>\n", + " <td>...</td>\n", + " <td>...</td>\n", + " </tr>\n", + " <tr>\n", + " <th>11157</th>\n", + " <td>33</td>\n", + " <td>blue-collar</td>\n", + " <td>single</td>\n", + " <td>primary</td>\n", + " <td>no</td>\n", + " <td>1</td>\n", + " <td>yes</td>\n", + " <td>no</td>\n", + " <td>cellular</td>\n", + " <td>20</td>\n", + " <td>apr</td>\n", + " <td>257</td>\n", + " <td>1</td>\n", + " <td>-1</td>\n", + " <td>0</td>\n", + " <td>unknown</td>\n", + " <td>no</td>\n", + " </tr>\n", + " <tr>\n", + " <th>11158</th>\n", + " <td>39</td>\n", + " <td>services</td>\n", + " <td>married</td>\n", + " <td>secondary</td>\n", + " <td>no</td>\n", + " <td>733</td>\n", + " <td>no</td>\n", + " <td>no</td>\n", + " <td>unknown</td>\n", + " <td>16</td>\n", + " <td>jun</td>\n", + " <td>83</td>\n", + " <td>4</td>\n", + " <td>-1</td>\n", + " <td>0</td>\n", + " <td>unknown</td>\n", + " <td>no</td>\n", + " </tr>\n", + " <tr>\n", + " <th>11159</th>\n", + " <td>32</td>\n", + " <td>technician</td>\n", + " <td>single</td>\n", + " <td>secondary</td>\n", + " <td>no</td>\n", + " <td>29</td>\n", + " <td>no</td>\n", + " <td>no</td>\n", + " <td>cellular</td>\n", + " <td>19</td>\n", + " <td>aug</td>\n", + " <td>156</td>\n", + " <td>2</td>\n", + " <td>-1</td>\n", + " <td>0</td>\n", + " <td>unknown</td>\n", + " <td>no</td>\n", + " </tr>\n", + " <tr>\n", + " <th>11160</th>\n", + " <td>43</td>\n", + " <td>technician</td>\n", + " <td>married</td>\n", + " <td>secondary</td>\n", + " <td>no</td>\n", + " <td>0</td>\n", + " <td>no</td>\n", + " <td>yes</td>\n", + " <td>cellular</td>\n", + " <td>8</td>\n", + " <td>may</td>\n", + " <td>9</td>\n", + " <td>2</td>\n", + " <td>172</td>\n", + " <td>5</td>\n", + " <td>failure</td>\n", + " <td>no</td>\n", + " </tr>\n", + " <tr>\n", + " <th>11161</th>\n", + " <td>34</td>\n", + " <td>technician</td>\n", + " <td>married</td>\n", + " <td>secondary</td>\n", + " <td>no</td>\n", + " <td>0</td>\n", + " <td>no</td>\n", + " <td>no</td>\n", + " <td>cellular</td>\n", + " <td>9</td>\n", + " <td>jul</td>\n", + " <td>628</td>\n", + " <td>1</td>\n", + " <td>-1</td>\n", + " <td>0</td>\n", + " <td>unknown</td>\n", + " <td>no</td>\n", + " </tr>\n", + " </tbody>\n", + "</table>\n", + "<p>11162 rows × 17 columns</p>\n", + "</div>" + ], + "text/plain": [ + " age job marital education default balance housing loan \\\n", + "0 59 admin. married secondary no 2343 yes no \n", + "1 56 admin. married secondary no 45 no no \n", + "2 41 technician married secondary no 1270 yes no \n", + "3 55 services married secondary no 2476 yes no \n", + "4 54 admin. married tertiary no 184 no no \n", + "... ... ... ... ... ... ... ... ... \n", + "11157 33 blue-collar single primary no 1 yes no \n", + "11158 39 services married secondary no 733 no no \n", + "11159 32 technician single secondary no 29 no no \n", + "11160 43 technician married secondary no 0 no yes \n", + "11161 34 technician married secondary no 0 no no \n", + "\n", + " contact day month duration campaign pdays previous poutcome \\\n", + "0 unknown 5 may 1042 1 -1 0 unknown \n", + "1 unknown 5 may 1467 1 -1 0 unknown \n", + "2 unknown 5 may 1389 1 -1 0 unknown \n", + "3 unknown 5 may 579 1 -1 0 unknown \n", + "4 unknown 5 may 673 2 -1 0 unknown \n", + "... ... ... ... ... ... ... ... ... \n", + "11157 cellular 20 apr 257 1 -1 0 unknown \n", + "11158 unknown 16 jun 83 4 -1 0 unknown \n", + "11159 cellular 19 aug 156 2 -1 0 unknown \n", + "11160 cellular 8 may 9 2 172 5 failure \n", + "11161 cellular 9 jul 628 1 -1 0 unknown \n", + "\n", + " deposit \n", + "0 yes \n", + "1 yes \n", + "2 yes \n", + "3 yes \n", + "4 yes \n", + "... ... \n", + "11157 no \n", + "11158 no \n", + "11159 no \n", + "11160 no \n", + "11161 no \n", + "\n", + "[11162 rows x 17 columns]" + ] + }, + "execution_count": 13, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "import numpy as np\n", + "#remove outliers\n", + "removed_outliers=remove_outliers(data, numeric_cols)\n", + "(removed_outliers)" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "<ipython-input-4-c8f6f2d77743>:89: FutureWarning: The default value of regex will change from True to False in a future version.\n", + " data[col] = data[col].str.replace(r'\\W+', '').str.strip() #replaces special characters with white sapaces and removes the white spaces\n" + ] + }, + { + "data": { + "text/html": [ + "<div>\n", + "<style scoped>\n", + " .dataframe tbody tr th:only-of-type {\n", + " vertical-align: middle;\n", + " }\n", + "\n", + " .dataframe tbody tr th {\n", + " vertical-align: top;\n", + " }\n", + "\n", + " .dataframe thead th {\n", + " text-align: right;\n", + " }\n", + "</style>\n", + "<table border=\"1\" class=\"dataframe\">\n", + " <thead>\n", + " <tr style=\"text-align: right;\">\n", + " <th></th>\n", + " <th>age</th>\n", + " <th>job</th>\n", + " <th>marital</th>\n", + " <th>education</th>\n", + " <th>default</th>\n", + " <th>balance</th>\n", + " <th>housing</th>\n", + " <th>loan</th>\n", + " <th>contact</th>\n", + " <th>day</th>\n", + " <th>month</th>\n", + " <th>duration</th>\n", + " <th>campaign</th>\n", + " <th>pdays</th>\n", + " <th>previous</th>\n", + " <th>poutcome</th>\n", + " <th>deposit</th>\n", + " </tr>\n", + " </thead>\n", + " <tbody>\n", + " <tr>\n", + " <th>0</th>\n", + " <td>59</td>\n", + " <td>admin</td>\n", + " <td>married</td>\n", + " <td>secondary</td>\n", + " <td>no</td>\n", + " <td>2343</td>\n", + " <td>yes</td>\n", + " <td>no</td>\n", + " <td>unknown</td>\n", + " <td>5</td>\n", + " <td>may</td>\n", + " <td>1042</td>\n", + " <td>1</td>\n", + " <td>-1</td>\n", + " <td>0</td>\n", + " <td>unknown</td>\n", + " <td>yes</td>\n", + " </tr>\n", + " <tr>\n", + " <th>1</th>\n", + " <td>56</td>\n", + " <td>admin</td>\n", + " <td>married</td>\n", + " <td>secondary</td>\n", + " <td>no</td>\n", + " <td>45</td>\n", + " <td>no</td>\n", + " <td>no</td>\n", + " <td>unknown</td>\n", + " <td>5</td>\n", + " <td>may</td>\n", + " <td>1467</td>\n", + " <td>1</td>\n", + " <td>-1</td>\n", + " <td>0</td>\n", + " <td>unknown</td>\n", + " <td>yes</td>\n", + " </tr>\n", + " <tr>\n", + " <th>2</th>\n", + " <td>41</td>\n", + " <td>technician</td>\n", + " <td>married</td>\n", + " <td>secondary</td>\n", + " <td>no</td>\n", + " <td>1270</td>\n", + " <td>yes</td>\n", + " <td>no</td>\n", + " <td>unknown</td>\n", + " <td>5</td>\n", + " <td>may</td>\n", + " <td>1389</td>\n", + " <td>1</td>\n", + " <td>-1</td>\n", + " <td>0</td>\n", + " <td>unknown</td>\n", + " <td>yes</td>\n", + " </tr>\n", + " <tr>\n", + " <th>3</th>\n", + " <td>55</td>\n", + " <td>services</td>\n", + " <td>married</td>\n", + " <td>secondary</td>\n", + " <td>no</td>\n", + " <td>2476</td>\n", + " <td>yes</td>\n", + " <td>no</td>\n", + " <td>unknown</td>\n", + " <td>5</td>\n", + " <td>may</td>\n", + " <td>579</td>\n", + " <td>1</td>\n", + " <td>-1</td>\n", + " <td>0</td>\n", + " <td>unknown</td>\n", + " <td>yes</td>\n", + " </tr>\n", + " <tr>\n", + " <th>4</th>\n", + " <td>54</td>\n", + " <td>admin</td>\n", + " <td>married</td>\n", + " <td>tertiary</td>\n", + " <td>no</td>\n", + " <td>184</td>\n", + " <td>no</td>\n", + " <td>no</td>\n", + " <td>unknown</td>\n", + " <td>5</td>\n", + " <td>may</td>\n", + " <td>673</td>\n", + " <td>2</td>\n", + " <td>-1</td>\n", + " <td>0</td>\n", + " <td>unknown</td>\n", + " <td>yes</td>\n", + " </tr>\n", + " <tr>\n", + " <th>...</th>\n", + " <td>...</td>\n", + " <td>...</td>\n", + " <td>...</td>\n", + " <td>...</td>\n", + " <td>...</td>\n", + " <td>...</td>\n", + " <td>...</td>\n", + " <td>...</td>\n", + " <td>...</td>\n", + " <td>...</td>\n", + " <td>...</td>\n", + " <td>...</td>\n", + " <td>...</td>\n", + " <td>...</td>\n", + " <td>...</td>\n", + " <td>...</td>\n", + " <td>...</td>\n", + " </tr>\n", + " <tr>\n", + " <th>11157</th>\n", + " <td>33</td>\n", + " <td>bluecollar</td>\n", + " <td>single</td>\n", + " <td>primary</td>\n", + " <td>no</td>\n", + " <td>1</td>\n", + " <td>yes</td>\n", + " <td>no</td>\n", + " <td>cellular</td>\n", + " <td>20</td>\n", + " <td>apr</td>\n", + " <td>257</td>\n", + " <td>1</td>\n", + " <td>-1</td>\n", + " <td>0</td>\n", + " <td>unknown</td>\n", + " <td>no</td>\n", + " </tr>\n", + " <tr>\n", + " <th>11158</th>\n", + " <td>39</td>\n", + " <td>services</td>\n", + " <td>married</td>\n", + " <td>secondary</td>\n", + " <td>no</td>\n", + " <td>733</td>\n", + " <td>no</td>\n", + " <td>no</td>\n", + " <td>unknown</td>\n", + " <td>16</td>\n", + " <td>jun</td>\n", + " <td>83</td>\n", + " <td>4</td>\n", + " <td>-1</td>\n", + " <td>0</td>\n", + " <td>unknown</td>\n", + " <td>no</td>\n", + " </tr>\n", + " <tr>\n", + " <th>11159</th>\n", + " <td>32</td>\n", + " <td>technician</td>\n", + " <td>single</td>\n", + " <td>secondary</td>\n", + " <td>no</td>\n", + " <td>29</td>\n", + " <td>no</td>\n", + " <td>no</td>\n", + " <td>cellular</td>\n", + " <td>19</td>\n", + " <td>aug</td>\n", + " <td>156</td>\n", + " <td>2</td>\n", + " <td>-1</td>\n", + " <td>0</td>\n", + " <td>unknown</td>\n", + " <td>no</td>\n", + " </tr>\n", + " <tr>\n", + " <th>11160</th>\n", + " <td>43</td>\n", + " <td>technician</td>\n", + " <td>married</td>\n", + " <td>secondary</td>\n", + " <td>no</td>\n", + " <td>0</td>\n", + " <td>no</td>\n", + " <td>yes</td>\n", + " <td>cellular</td>\n", + " <td>8</td>\n", + " <td>may</td>\n", + " <td>9</td>\n", + " <td>2</td>\n", + " <td>172</td>\n", + " <td>5</td>\n", + " <td>failure</td>\n", + " <td>no</td>\n", + " </tr>\n", + " <tr>\n", + " <th>11161</th>\n", + " <td>34</td>\n", + " <td>technician</td>\n", + " <td>married</td>\n", + " <td>secondary</td>\n", + " <td>no</td>\n", + " <td>0</td>\n", + " <td>no</td>\n", + " <td>no</td>\n", + " <td>cellular</td>\n", + " <td>9</td>\n", + " <td>jul</td>\n", + " <td>628</td>\n", + " <td>1</td>\n", + " <td>-1</td>\n", + " <td>0</td>\n", + " <td>unknown</td>\n", + " <td>no</td>\n", + " </tr>\n", + " </tbody>\n", + "</table>\n", + "<p>11162 rows × 17 columns</p>\n", + "</div>" + ], + "text/plain": [ + " age job marital education default balance housing loan \\\n", + "0 59 admin married secondary no 2343 yes no \n", + "1 56 admin married secondary no 45 no no \n", + "2 41 technician married secondary no 1270 yes no \n", + "3 55 services married secondary no 2476 yes no \n", + "4 54 admin married tertiary no 184 no no \n", + "... ... ... ... ... ... ... ... ... \n", + "11157 33 bluecollar single primary no 1 yes no \n", + "11158 39 services married secondary no 733 no no \n", + "11159 32 technician single secondary no 29 no no \n", + "11160 43 technician married secondary no 0 no yes \n", + "11161 34 technician married secondary no 0 no no \n", + "\n", + " contact day month duration campaign pdays previous poutcome \\\n", + "0 unknown 5 may 1042 1 -1 0 unknown \n", + "1 unknown 5 may 1467 1 -1 0 unknown \n", + "2 unknown 5 may 1389 1 -1 0 unknown \n", + "3 unknown 5 may 579 1 -1 0 unknown \n", + "4 unknown 5 may 673 2 -1 0 unknown \n", + "... ... ... ... ... ... ... ... ... \n", + "11157 cellular 20 apr 257 1 -1 0 unknown \n", + "11158 unknown 16 jun 83 4 -1 0 unknown \n", + "11159 cellular 19 aug 156 2 -1 0 unknown \n", + "11160 cellular 8 may 9 2 172 5 failure \n", + "11161 cellular 9 jul 628 1 -1 0 unknown \n", + "\n", + " deposit \n", + "0 yes \n", + "1 yes \n", + "2 yes \n", + "3 yes \n", + "4 yes \n", + "... ... \n", + "11157 no \n", + "11158 no \n", + "11159 no \n", + "11160 no \n", + "11161 no \n", + "\n", + "[11162 rows x 17 columns]" + ] + }, + "execution_count": 14, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "removed_special_chars = remove_spec_chars(removed_outliers, categorical_cols)\n", + "\n", + "removed_special_chars" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "<div>\n", + "<style scoped>\n", + " .dataframe tbody tr th:only-of-type {\n", + " vertical-align: middle;\n", + " }\n", + "\n", + " .dataframe tbody tr th {\n", + " vertical-align: top;\n", + " }\n", + "\n", + " .dataframe thead th {\n", + " text-align: right;\n", + " }\n", + "</style>\n", + "<table border=\"1\" class=\"dataframe\">\n", + " <thead>\n", + " <tr style=\"text-align: right;\">\n", + " <th></th>\n", + " <th>age</th>\n", + " <th>job</th>\n", + " <th>marital</th>\n", + " <th>education</th>\n", + " <th>default</th>\n", + " <th>balance</th>\n", + " <th>housing</th>\n", + " <th>loan</th>\n", + " <th>contact</th>\n", + " <th>day</th>\n", + " <th>month</th>\n", + " <th>duration</th>\n", + " <th>campaign</th>\n", + " <th>pdays</th>\n", + " <th>previous</th>\n", + " <th>poutcome</th>\n", + " <th>deposit</th>\n", + " </tr>\n", + " </thead>\n", + " <tbody>\n", + " <tr>\n", + " <th>0</th>\n", + " <td>59</td>\n", + " <td>admin</td>\n", + " <td>married</td>\n", + " <td>secondary</td>\n", + " <td>no</td>\n", + " <td>2343</td>\n", + " <td>yes</td>\n", + " <td>no</td>\n", + " <td>cellular</td>\n", + " <td>5</td>\n", + " <td>may</td>\n", + " <td>1042</td>\n", + " <td>1</td>\n", + " <td>-1</td>\n", + " <td>0</td>\n", + " <td>unknown</td>\n", + " <td>yes</td>\n", + " </tr>\n", + " <tr>\n", + " <th>1</th>\n", + " <td>56</td>\n", + " <td>admin</td>\n", + " <td>married</td>\n", + " <td>secondary</td>\n", + " <td>no</td>\n", + " <td>45</td>\n", + " <td>no</td>\n", + " <td>no</td>\n", + " <td>cellular</td>\n", + " <td>5</td>\n", + " <td>may</td>\n", + " <td>1467</td>\n", + " <td>1</td>\n", + " <td>-1</td>\n", + " <td>0</td>\n", + " <td>unknown</td>\n", + " <td>yes</td>\n", + " </tr>\n", + " <tr>\n", + " <th>2</th>\n", + " <td>41</td>\n", + " <td>technician</td>\n", + " <td>married</td>\n", + " <td>secondary</td>\n", + " <td>no</td>\n", + " <td>1270</td>\n", + " <td>yes</td>\n", + " <td>no</td>\n", + " <td>cellular</td>\n", + " <td>5</td>\n", + " <td>may</td>\n", + " <td>1389</td>\n", + " <td>1</td>\n", + " <td>-1</td>\n", + " <td>0</td>\n", + " <td>unknown</td>\n", + " <td>yes</td>\n", + " </tr>\n", + " <tr>\n", + " <th>3</th>\n", + " <td>55</td>\n", + " <td>services</td>\n", + " <td>married</td>\n", + " <td>secondary</td>\n", + " <td>no</td>\n", + " <td>2476</td>\n", + " <td>yes</td>\n", + " <td>no</td>\n", + " <td>cellular</td>\n", + " <td>5</td>\n", + " <td>may</td>\n", + " <td>579</td>\n", + " <td>1</td>\n", + " <td>-1</td>\n", + " <td>0</td>\n", + " <td>unknown</td>\n", + " <td>yes</td>\n", + " </tr>\n", + " <tr>\n", + " <th>4</th>\n", + " <td>54</td>\n", + " <td>admin</td>\n", + " <td>married</td>\n", + " <td>tertiary</td>\n", + " <td>no</td>\n", + " <td>184</td>\n", + " <td>no</td>\n", + " <td>no</td>\n", + " <td>cellular</td>\n", + " <td>5</td>\n", + " <td>may</td>\n", + " <td>673</td>\n", + " <td>2</td>\n", + " <td>-1</td>\n", + " <td>0</td>\n", + " <td>unknown</td>\n", + " <td>yes</td>\n", + " </tr>\n", + " <tr>\n", + " <th>...</th>\n", + " <td>...</td>\n", + " <td>...</td>\n", + " <td>...</td>\n", + " <td>...</td>\n", + " <td>...</td>\n", + " <td>...</td>\n", + " <td>...</td>\n", + " <td>...</td>\n", + " <td>...</td>\n", + " <td>...</td>\n", + " <td>...</td>\n", + " <td>...</td>\n", + " <td>...</td>\n", + " <td>...</td>\n", + " <td>...</td>\n", + " <td>...</td>\n", + " <td>...</td>\n", + " </tr>\n", + " <tr>\n", + " <th>11157</th>\n", + " <td>33</td>\n", + " <td>bluecollar</td>\n", + " <td>single</td>\n", + " <td>primary</td>\n", + " <td>no</td>\n", + " <td>1</td>\n", + " <td>yes</td>\n", + " <td>no</td>\n", + " <td>cellular</td>\n", + " <td>20</td>\n", + " <td>apr</td>\n", + " <td>257</td>\n", + " <td>1</td>\n", + " <td>-1</td>\n", + " <td>0</td>\n", + " <td>unknown</td>\n", + " <td>no</td>\n", + " </tr>\n", + " <tr>\n", + " <th>11158</th>\n", + " <td>39</td>\n", + " <td>services</td>\n", + " <td>married</td>\n", + " <td>secondary</td>\n", + " <td>no</td>\n", + " <td>733</td>\n", + " <td>no</td>\n", + " <td>no</td>\n", + " <td>cellular</td>\n", + " <td>16</td>\n", + " <td>jun</td>\n", + " <td>83</td>\n", + " <td>4</td>\n", + " <td>-1</td>\n", + " <td>0</td>\n", + " <td>unknown</td>\n", + " <td>no</td>\n", + " </tr>\n", + " <tr>\n", + " <th>11159</th>\n", + " <td>32</td>\n", + " <td>technician</td>\n", + " <td>single</td>\n", + " <td>secondary</td>\n", + " <td>no</td>\n", + " <td>29</td>\n", + " <td>no</td>\n", + " <td>no</td>\n", + " <td>cellular</td>\n", + " <td>19</td>\n", + " <td>aug</td>\n", + " <td>156</td>\n", + " <td>2</td>\n", + " <td>-1</td>\n", + " <td>0</td>\n", + " <td>unknown</td>\n", + " <td>no</td>\n", + " </tr>\n", + " <tr>\n", + " <th>11160</th>\n", + " <td>43</td>\n", + " <td>technician</td>\n", + " <td>married</td>\n", + " <td>secondary</td>\n", + " <td>no</td>\n", + " <td>0</td>\n", + " <td>no</td>\n", + " <td>yes</td>\n", + " <td>cellular</td>\n", + " <td>8</td>\n", + " <td>may</td>\n", + " <td>9</td>\n", + " <td>2</td>\n", + " <td>172</td>\n", + " <td>5</td>\n", + " <td>failure</td>\n", + " <td>no</td>\n", + " </tr>\n", + " <tr>\n", + " <th>11161</th>\n", + " <td>34</td>\n", + " <td>technician</td>\n", + " <td>married</td>\n", + " <td>secondary</td>\n", + " <td>no</td>\n", + " <td>0</td>\n", + " <td>no</td>\n", + " <td>no</td>\n", + " <td>cellular</td>\n", + " <td>9</td>\n", + " <td>jul</td>\n", + " <td>628</td>\n", + " <td>1</td>\n", + " <td>-1</td>\n", + " <td>0</td>\n", + " <td>unknown</td>\n", + " <td>no</td>\n", + " </tr>\n", + " </tbody>\n", + "</table>\n", + "<p>11162 rows × 17 columns</p>\n", + "</div>" + ], + "text/plain": [ + " age job marital education default balance housing loan \\\n", + "0 59 admin married secondary no 2343 yes no \n", + "1 56 admin married secondary no 45 no no \n", + "2 41 technician married secondary no 1270 yes no \n", + "3 55 services married secondary no 2476 yes no \n", + "4 54 admin married tertiary no 184 no no \n", + "... ... ... ... ... ... ... ... ... \n", + "11157 33 bluecollar single primary no 1 yes no \n", + "11158 39 services married secondary no 733 no no \n", + "11159 32 technician single secondary no 29 no no \n", + "11160 43 technician married secondary no 0 no yes \n", + "11161 34 technician married secondary no 0 no no \n", + "\n", + " contact day month duration campaign pdays previous poutcome \\\n", + "0 cellular 5 may 1042 1 -1 0 unknown \n", + "1 cellular 5 may 1467 1 -1 0 unknown \n", + "2 cellular 5 may 1389 1 -1 0 unknown \n", + "3 cellular 5 may 579 1 -1 0 unknown \n", + "4 cellular 5 may 673 2 -1 0 unknown \n", + "... ... ... ... ... ... ... ... ... \n", + "11157 cellular 20 apr 257 1 -1 0 unknown \n", + "11158 cellular 16 jun 83 4 -1 0 unknown \n", + "11159 cellular 19 aug 156 2 -1 0 unknown \n", + "11160 cellular 8 may 9 2 172 5 failure \n", + "11161 cellular 9 jul 628 1 -1 0 unknown \n", + "\n", + " deposit \n", + "0 yes \n", + "1 yes \n", + "2 yes \n", + "3 yes \n", + "4 yes \n", + "... ... \n", + "11157 no \n", + "11158 no \n", + "11159 no \n", + "11160 no \n", + "11161 no \n", + "\n", + "[11162 rows x 17 columns]" + ] + }, + "execution_count": 15, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "#replace unknown with mode\n", + "\n", + "removed_unknown = replace_unknown(removed_special_chars, categorical_cols)\n", + "\n", + "removed_unknown" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "<div>\n", + "<style scoped>\n", + " .dataframe tbody tr th:only-of-type {\n", + " vertical-align: middle;\n", + " }\n", + "\n", + " .dataframe tbody tr th {\n", + " vertical-align: top;\n", + " }\n", + "\n", + " .dataframe thead th {\n", + " text-align: right;\n", + " }\n", + "</style>\n", + "<table border=\"1\" class=\"dataframe\">\n", + " <thead>\n", + " <tr style=\"text-align: right;\">\n", + " <th></th>\n", + " <th>age</th>\n", + " <th>job</th>\n", + " <th>marital</th>\n", + " <th>education</th>\n", + " <th>default</th>\n", + " <th>balance</th>\n", + " <th>housing</th>\n", + " <th>loan</th>\n", + " <th>contact</th>\n", + " <th>day</th>\n", + " <th>month</th>\n", + " <th>duration</th>\n", + " <th>campaign</th>\n", + " <th>pdays</th>\n", + " <th>previous</th>\n", + " <th>deposit</th>\n", + " </tr>\n", + " </thead>\n", + " <tbody>\n", + " <tr>\n", + " <th>0</th>\n", + " <td>59</td>\n", + " <td>admin</td>\n", + " <td>married</td>\n", + " <td>secondary</td>\n", + " <td>no</td>\n", + " <td>2343</td>\n", + " <td>yes</td>\n", + " <td>no</td>\n", + " <td>cellular</td>\n", + " <td>5</td>\n", + " <td>may</td>\n", + " <td>1042</td>\n", + " <td>1</td>\n", + " <td>-1</td>\n", + " <td>0</td>\n", + " <td>yes</td>\n", + " </tr>\n", + " <tr>\n", + " <th>1</th>\n", + " <td>56</td>\n", + " <td>admin</td>\n", + " <td>married</td>\n", + " <td>secondary</td>\n", + " <td>no</td>\n", + " <td>45</td>\n", + " <td>no</td>\n", + " <td>no</td>\n", + " <td>cellular</td>\n", + " <td>5</td>\n", + " <td>may</td>\n", + " <td>1467</td>\n", + " <td>1</td>\n", + " <td>-1</td>\n", + " <td>0</td>\n", + " <td>yes</td>\n", + " </tr>\n", + " <tr>\n", + " <th>2</th>\n", + " <td>41</td>\n", + " <td>technician</td>\n", + " <td>married</td>\n", + " <td>secondary</td>\n", + " <td>no</td>\n", + " <td>1270</td>\n", + " <td>yes</td>\n", + " <td>no</td>\n", + " <td>cellular</td>\n", + " <td>5</td>\n", + " <td>may</td>\n", + " <td>1389</td>\n", + " <td>1</td>\n", + " <td>-1</td>\n", + " <td>0</td>\n", + " <td>yes</td>\n", + " </tr>\n", + " <tr>\n", + " <th>3</th>\n", + " <td>55</td>\n", + " <td>services</td>\n", + " <td>married</td>\n", + " <td>secondary</td>\n", + " <td>no</td>\n", + " <td>2476</td>\n", + " <td>yes</td>\n", + " <td>no</td>\n", + " <td>cellular</td>\n", + " <td>5</td>\n", + " <td>may</td>\n", + " <td>579</td>\n", + " <td>1</td>\n", + " <td>-1</td>\n", + " <td>0</td>\n", + " <td>yes</td>\n", + " </tr>\n", + " <tr>\n", + " <th>4</th>\n", + " <td>54</td>\n", + " <td>admin</td>\n", + " <td>married</td>\n", + " <td>tertiary</td>\n", + " <td>no</td>\n", + " <td>184</td>\n", + " <td>no</td>\n", + " <td>no</td>\n", + " <td>cellular</td>\n", + " <td>5</td>\n", + " <td>may</td>\n", + " <td>673</td>\n", + " <td>2</td>\n", + " <td>-1</td>\n", + " <td>0</td>\n", + " <td>yes</td>\n", + " </tr>\n", + " <tr>\n", + " <th>...</th>\n", + " <td>...</td>\n", + " <td>...</td>\n", + " <td>...</td>\n", + " <td>...</td>\n", + " <td>...</td>\n", + " <td>...</td>\n", + " <td>...</td>\n", + " <td>...</td>\n", + " <td>...</td>\n", + " <td>...</td>\n", + " <td>...</td>\n", + " <td>...</td>\n", + " <td>...</td>\n", + " <td>...</td>\n", + " <td>...</td>\n", + " <td>...</td>\n", + " </tr>\n", + " <tr>\n", + " <th>11157</th>\n", + " <td>33</td>\n", + " <td>bluecollar</td>\n", + " <td>single</td>\n", + " <td>primary</td>\n", + " <td>no</td>\n", + " <td>1</td>\n", + " <td>yes</td>\n", + " <td>no</td>\n", + " <td>cellular</td>\n", + " <td>20</td>\n", + " <td>apr</td>\n", + " <td>257</td>\n", + " <td>1</td>\n", + " <td>-1</td>\n", + " <td>0</td>\n", + " <td>no</td>\n", + " </tr>\n", + " <tr>\n", + " <th>11158</th>\n", + " <td>39</td>\n", + " <td>services</td>\n", + " <td>married</td>\n", + " <td>secondary</td>\n", + " <td>no</td>\n", + " <td>733</td>\n", + " <td>no</td>\n", + " <td>no</td>\n", + " <td>cellular</td>\n", + " <td>16</td>\n", + " <td>jun</td>\n", + " <td>83</td>\n", + " <td>4</td>\n", + " <td>-1</td>\n", + " <td>0</td>\n", + " <td>no</td>\n", + " </tr>\n", + " <tr>\n", + " <th>11159</th>\n", + " <td>32</td>\n", + " <td>technician</td>\n", + " <td>single</td>\n", + " <td>secondary</td>\n", + " <td>no</td>\n", + " <td>29</td>\n", + " <td>no</td>\n", + " <td>no</td>\n", + " <td>cellular</td>\n", + " <td>19</td>\n", + " <td>aug</td>\n", + " <td>156</td>\n", + " <td>2</td>\n", + " <td>-1</td>\n", + " <td>0</td>\n", + " <td>no</td>\n", + " </tr>\n", + " <tr>\n", + " <th>11160</th>\n", + " <td>43</td>\n", + " <td>technician</td>\n", + " <td>married</td>\n", + " <td>secondary</td>\n", + " <td>no</td>\n", + " <td>0</td>\n", + " <td>no</td>\n", + " <td>yes</td>\n", + " <td>cellular</td>\n", + " <td>8</td>\n", + " <td>may</td>\n", + " <td>9</td>\n", + " <td>2</td>\n", + " <td>172</td>\n", + " <td>5</td>\n", + " <td>no</td>\n", + " </tr>\n", + " <tr>\n", + " <th>11161</th>\n", + " <td>34</td>\n", + " <td>technician</td>\n", + " <td>married</td>\n", + " <td>secondary</td>\n", + " <td>no</td>\n", + " <td>0</td>\n", + " <td>no</td>\n", + " <td>no</td>\n", + " <td>cellular</td>\n", + " <td>9</td>\n", + " <td>jul</td>\n", + " <td>628</td>\n", + " <td>1</td>\n", + " <td>-1</td>\n", + " <td>0</td>\n", + " <td>no</td>\n", + " </tr>\n", + " </tbody>\n", + "</table>\n", + "<p>11162 rows × 16 columns</p>\n", + "</div>" + ], + "text/plain": [ + " age job marital education default balance housing loan \\\n", + "0 59 admin married secondary no 2343 yes no \n", + "1 56 admin married secondary no 45 no no \n", + "2 41 technician married secondary no 1270 yes no \n", + "3 55 services married secondary no 2476 yes no \n", + "4 54 admin married tertiary no 184 no no \n", + "... ... ... ... ... ... ... ... ... \n", + "11157 33 bluecollar single primary no 1 yes no \n", + "11158 39 services married secondary no 733 no no \n", + "11159 32 technician single secondary no 29 no no \n", + "11160 43 technician married secondary no 0 no yes \n", + "11161 34 technician married secondary no 0 no no \n", + "\n", + " contact day month duration campaign pdays previous deposit \n", + "0 cellular 5 may 1042 1 -1 0 yes \n", + "1 cellular 5 may 1467 1 -1 0 yes \n", + "2 cellular 5 may 1389 1 -1 0 yes \n", + "3 cellular 5 may 579 1 -1 0 yes \n", + "4 cellular 5 may 673 2 -1 0 yes \n", + "... ... ... ... ... ... ... ... ... \n", + "11157 cellular 20 apr 257 1 -1 0 no \n", + "11158 cellular 16 jun 83 4 -1 0 no \n", + "11159 cellular 19 aug 156 2 -1 0 no \n", + "11160 cellular 8 may 9 2 172 5 no \n", + "11161 cellular 9 jul 628 1 -1 0 no \n", + "\n", + "[11162 rows x 16 columns]" + ] + }, + "execution_count": 16, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "#drop \"poutcocme column\"\n", + "categorical_cols.remove('poutcome')\n", + "\n", + "dropped_column = removed_unknown.drop(columns=[\"poutcome\"])\n", + "\n", + "dropped_column" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "<div>\n", + "<style scoped>\n", + " .dataframe tbody tr th:only-of-type {\n", + " vertical-align: middle;\n", + " }\n", + "\n", + " .dataframe tbody tr th {\n", + " vertical-align: top;\n", + " }\n", + "\n", + " .dataframe thead th {\n", + " text-align: right;\n", + " }\n", + "</style>\n", + "<table border=\"1\" class=\"dataframe\">\n", + " <thead>\n", + " <tr style=\"text-align: right;\">\n", + " <th></th>\n", + " <th>age</th>\n", + " <th>balance</th>\n", + " <th>day</th>\n", + " <th>duration</th>\n", + " <th>campaign</th>\n", + " <th>pdays</th>\n", + " <th>previous</th>\n", + " <th>job_bluecollar</th>\n", + " <th>job_entrepreneur</th>\n", + " <th>job_housemaid</th>\n", + " <th>job_management</th>\n", + " <th>job_retired</th>\n", + " <th>job_selfemployed</th>\n", + " <th>job_services</th>\n", + " <th>job_student</th>\n", + " <th>job_technician</th>\n", + " <th>job_unemployed</th>\n", + " <th>marital_married</th>\n", + " <th>marital_single</th>\n", + " <th>education_secondary</th>\n", + " <th>education_tertiary</th>\n", + " <th>default_yes</th>\n", + " <th>housing_yes</th>\n", + " <th>loan_yes</th>\n", + " <th>contact_telephone</th>\n", + " <th>month_aug</th>\n", + " <th>month_dec</th>\n", + " <th>month_feb</th>\n", + " <th>month_jan</th>\n", + " <th>month_jul</th>\n", + " <th>month_jun</th>\n", + " <th>month_mar</th>\n", + " <th>month_may</th>\n", + " <th>month_nov</th>\n", + " <th>month_oct</th>\n", + " <th>month_sep</th>\n", + " <th>deposit_yes</th>\n", + " </tr>\n", + " </thead>\n", + " <tbody>\n", + " <tr>\n", + " <th>0</th>\n", + " <td>59</td>\n", + " <td>2343</td>\n", + " <td>5</td>\n", + " <td>1042</td>\n", + " <td>1</td>\n", + " <td>-1</td>\n", + " <td>0</td>\n", + " <td>0</td>\n", + " <td>0</td>\n", + " <td>0</td>\n", + " <td>0</td>\n", + " <td>0</td>\n", + " <td>0</td>\n", + " <td>0</td>\n", + " <td>0</td>\n", + " <td>0</td>\n", + " <td>0</td>\n", + " <td>1</td>\n", + " <td>0</td>\n", + " <td>1</td>\n", + " <td>0</td>\n", + " <td>0</td>\n", + " <td>1</td>\n", + " <td>0</td>\n", + " <td>0</td>\n", + " <td>0</td>\n", + " <td>0</td>\n", + " <td>0</td>\n", + " <td>0</td>\n", + " <td>0</td>\n", + " <td>0</td>\n", + " <td>0</td>\n", + " <td>1</td>\n", + " <td>0</td>\n", + " <td>0</td>\n", + " <td>0</td>\n", + " <td>1</td>\n", + " </tr>\n", + " <tr>\n", + " <th>1</th>\n", + " <td>56</td>\n", + " <td>45</td>\n", + " <td>5</td>\n", + " <td>1467</td>\n", + " <td>1</td>\n", + " <td>-1</td>\n", + " <td>0</td>\n", + " <td>0</td>\n", + " <td>0</td>\n", + " <td>0</td>\n", + " <td>0</td>\n", + " <td>0</td>\n", + " <td>0</td>\n", + " <td>0</td>\n", + " <td>0</td>\n", + " <td>0</td>\n", + " <td>0</td>\n", + " <td>1</td>\n", + " <td>0</td>\n", + " <td>1</td>\n", + " <td>0</td>\n", + " <td>0</td>\n", + " <td>0</td>\n", + " <td>0</td>\n", + " <td>0</td>\n", + " <td>0</td>\n", + " <td>0</td>\n", + " <td>0</td>\n", + " <td>0</td>\n", + " <td>0</td>\n", + " <td>0</td>\n", + " <td>0</td>\n", + " <td>1</td>\n", + " <td>0</td>\n", + " <td>0</td>\n", + " <td>0</td>\n", + " <td>1</td>\n", + " </tr>\n", + " <tr>\n", + " <th>2</th>\n", + " <td>41</td>\n", + " <td>1270</td>\n", + " <td>5</td>\n", + " <td>1389</td>\n", + " <td>1</td>\n", + " <td>-1</td>\n", + " <td>0</td>\n", + " <td>0</td>\n", + " <td>0</td>\n", + " <td>0</td>\n", + " <td>0</td>\n", + " <td>0</td>\n", + " <td>0</td>\n", + " <td>0</td>\n", + " <td>0</td>\n", + " <td>1</td>\n", + " <td>0</td>\n", + " <td>1</td>\n", + " <td>0</td>\n", + " <td>1</td>\n", + " <td>0</td>\n", + " <td>0</td>\n", + " <td>1</td>\n", + " <td>0</td>\n", + " <td>0</td>\n", + " <td>0</td>\n", + " <td>0</td>\n", + " <td>0</td>\n", + " <td>0</td>\n", + " <td>0</td>\n", + " <td>0</td>\n", + " <td>0</td>\n", + " <td>1</td>\n", + " <td>0</td>\n", + " <td>0</td>\n", + " <td>0</td>\n", + " <td>1</td>\n", + " </tr>\n", + " <tr>\n", + " <th>3</th>\n", + " <td>55</td>\n", + " <td>2476</td>\n", + " <td>5</td>\n", + " <td>579</td>\n", + " <td>1</td>\n", + " <td>-1</td>\n", + " <td>0</td>\n", + " <td>0</td>\n", + " <td>0</td>\n", + " <td>0</td>\n", + " <td>0</td>\n", + " <td>0</td>\n", + " <td>0</td>\n", + " <td>1</td>\n", + " <td>0</td>\n", + " <td>0</td>\n", + " <td>0</td>\n", + " <td>1</td>\n", + " <td>0</td>\n", + " <td>1</td>\n", + " <td>0</td>\n", + " <td>0</td>\n", + " <td>1</td>\n", + " <td>0</td>\n", + " <td>0</td>\n", + " <td>0</td>\n", + " <td>0</td>\n", + " <td>0</td>\n", + " <td>0</td>\n", + " <td>0</td>\n", + " <td>0</td>\n", + " <td>0</td>\n", + " <td>1</td>\n", + " <td>0</td>\n", + " <td>0</td>\n", + " <td>0</td>\n", + " <td>1</td>\n", + " </tr>\n", + " <tr>\n", + " <th>4</th>\n", + " <td>54</td>\n", + " <td>184</td>\n", + " <td>5</td>\n", + " <td>673</td>\n", + " <td>2</td>\n", + " <td>-1</td>\n", + " <td>0</td>\n", + " <td>0</td>\n", + " <td>0</td>\n", + " <td>0</td>\n", + " <td>0</td>\n", + " <td>0</td>\n", + " <td>0</td>\n", + " <td>0</td>\n", + " <td>0</td>\n", + " <td>0</td>\n", + " <td>0</td>\n", + " <td>1</td>\n", + " <td>0</td>\n", + " <td>0</td>\n", + " <td>1</td>\n", + " <td>0</td>\n", + " <td>0</td>\n", + " <td>0</td>\n", + " <td>0</td>\n", + " <td>0</td>\n", + " <td>0</td>\n", + " <td>0</td>\n", + " <td>0</td>\n", + " <td>0</td>\n", + " <td>0</td>\n", + " <td>0</td>\n", + " <td>1</td>\n", + " <td>0</td>\n", + " <td>0</td>\n", + " <td>0</td>\n", + " <td>1</td>\n", + " </tr>\n", + " </tbody>\n", + "</table>\n", + "</div>" + ], + "text/plain": [ + " age balance day duration campaign pdays previous job_bluecollar \\\n", + "0 59 2343 5 1042 1 -1 0 0 \n", + "1 56 45 5 1467 1 -1 0 0 \n", + "2 41 1270 5 1389 1 -1 0 0 \n", + "3 55 2476 5 579 1 -1 0 0 \n", + "4 54 184 5 673 2 -1 0 0 \n", + "\n", + " job_entrepreneur job_housemaid job_management job_retired \\\n", + "0 0 0 0 0 \n", + "1 0 0 0 0 \n", + "2 0 0 0 0 \n", + "3 0 0 0 0 \n", + "4 0 0 0 0 \n", + "\n", + " job_selfemployed job_services job_student job_technician \\\n", + "0 0 0 0 0 \n", + "1 0 0 0 0 \n", + "2 0 0 0 1 \n", + "3 0 1 0 0 \n", + "4 0 0 0 0 \n", + "\n", + " job_unemployed marital_married marital_single education_secondary \\\n", + "0 0 1 0 1 \n", + "1 0 1 0 1 \n", + "2 0 1 0 1 \n", + "3 0 1 0 1 \n", + "4 0 1 0 0 \n", + "\n", + " education_tertiary default_yes housing_yes loan_yes contact_telephone \\\n", + "0 0 0 1 0 0 \n", + "1 0 0 0 0 0 \n", + "2 0 0 1 0 0 \n", + "3 0 0 1 0 0 \n", + "4 1 0 0 0 0 \n", + "\n", + " month_aug month_dec month_feb month_jan month_jul month_jun \\\n", + "0 0 0 0 0 0 0 \n", + "1 0 0 0 0 0 0 \n", + "2 0 0 0 0 0 0 \n", + "3 0 0 0 0 0 0 \n", + "4 0 0 0 0 0 0 \n", + "\n", + " month_mar month_may month_nov month_oct month_sep deposit_yes \n", + "0 0 1 0 0 0 1 \n", + "1 0 1 0 0 0 1 \n", + "2 0 1 0 0 0 1 \n", + "3 0 1 0 0 0 1 \n", + "4 0 1 0 0 0 1 " + ] + }, + "execution_count": 17, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "#One hot encoding\n", + "\n", + "data_encoded = oneHotEncoding(dropped_column, categorical_cols, True)\n", + "\n", + "data_encoded.head()" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(11162, 37)" + ] + }, + "execution_count": 18, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "data_encoded.shape" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " age balance day duration campaign pdays previous job_bluecollar \\\n", + "0 59 2343 5 1042 1 -1 0 0 \n", + "1 56 45 5 1467 1 -1 0 0 \n", + "2 41 1270 5 1389 1 -1 0 0 \n", + "3 55 2476 5 579 1 -1 0 0 \n", + "4 54 184 5 673 2 -1 0 0 \n", + "\n", + " job_entrepreneur job_housemaid job_management job_retired \\\n", + "0 0 0 0 0 \n", + "1 0 0 0 0 \n", + "2 0 0 0 0 \n", + "3 0 0 0 0 \n", + "4 0 0 0 0 \n", + "\n", + " job_selfemployed job_services job_student job_technician \\\n", + "0 0 0 0 0 \n", + "1 0 0 0 0 \n", + "2 0 0 0 1 \n", + "3 0 1 0 0 \n", + "4 0 0 0 0 \n", + "\n", + " job_unemployed marital_married marital_single education_secondary \\\n", + "0 0 1 0 1 \n", + "1 0 1 0 1 \n", + "2 0 1 0 1 \n", + "3 0 1 0 1 \n", + "4 0 1 0 0 \n", + "\n", + " education_tertiary default_yes housing_yes loan_yes contact_telephone \\\n", + "0 0 0 1 0 0 \n", + "1 0 0 0 0 0 \n", + "2 0 0 1 0 0 \n", + "3 0 0 1 0 0 \n", + "4 1 0 0 0 0 \n", + "\n", + " month_aug month_dec month_feb month_jan month_jul month_jun \\\n", + "0 0 0 0 0 0 0 \n", + "1 0 0 0 0 0 0 \n", + "2 0 0 0 0 0 0 \n", + "3 0 0 0 0 0 0 \n", + "4 0 0 0 0 0 0 \n", + "\n", + " month_mar month_may month_nov month_oct month_sep deposit_yes \n", + "0 0 1 0 0 0 1 \n", + "1 0 1 0 0 0 1 \n", + "2 0 1 0 0 0 1 \n", + "3 0 1 0 0 0 1 \n", + "4 0 1 0 0 0 1 \n" + ] + } + ], + "source": [ + "# Convert boolean columns from True/False to 1/0\n", + "binary_data = data_encoded.applymap(lambda x: 1 if x is True else (0 if x is False else x))\n", + "\n", + "# Check if the conversion is successful\n", + "print(binary_data.head())" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [], + "source": [ + "from sklearn.preprocessing import StandardScaler\n", + "from sklearn.model_selection import train_test_split\n", + "from sklearn.metrics import accuracy_score\n", + "import matplotlib.pyplot as plt" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[[ 59 2343 5 ... 0 0 0]\n", + " [ 56 45 5 ... 0 0 0]\n", + " [ 41 1270 5 ... 0 0 0]\n", + " ...\n", + " [ 32 29 19 ... 0 0 0]\n", + " [ 43 0 8 ... 0 0 0]\n", + " [ 34 0 9 ... 0 0 0]]\n" + ] + } + ], + "source": [ + "# Define the states and actions\n", + "states = binary_data.drop(columns=['deposit_yes']).values\n", + "print(states)" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": {}, + "outputs": [], + "source": [ + "actions = [0, 1] # 0: no deposit, 1: deposit\n" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": {}, + "outputs": [], + "source": [ + "# Split data into training and testing\n", + "train_states, test_states, train_target, test_target = train_test_split(states, binary_data['deposit_yes'], test_size=0.2, random_state=42)" + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Accuracy of Q-learning policy: 49.57\n", + "Confusion Matrix for Q-learning:\n", + "[[572 594]\n", + " [532 535]]\n", + "Classification Report for Q-learning:\n", + " precision recall f1-score support\n", + "\n", + " 0 0.52 0.49 0.50 1166\n", + " 1 0.47 0.50 0.49 1067\n", + "\n", + " accuracy 0.50 2233\n", + " macro avg 0.50 0.50 0.50 2233\n", + "weighted avg 0.50 0.50 0.50 2233\n", + "\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "<Figure size 720x360 with 1 Axes>" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Accuracy of Double Q-learning policy: 49.84\n", + "Confusion Matrix for Double Q-learning:\n", + "[[582 584]\n", + " [536 531]]\n", + "Classification Report for Double Q-learning:\n", + " precision recall f1-score support\n", + "\n", + " 0 0.52 0.50 0.51 1166\n", + " 1 0.48 0.50 0.49 1067\n", + "\n", + " accuracy 0.50 2233\n", + " macro avg 0.50 0.50 0.50 2233\n", + "weighted avg 0.50 0.50 0.50 2233\n", + "\n" + ] + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAmoAAAFNCAYAAACwk0NsAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuNCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8QVMy6AAAACXBIWXMAAAsTAAALEwEAmpwYAABLRklEQVR4nO3dd3gc1dn38e+t3i2ruMkd996xMTbGDi00h05CYgh5eJLQEhISIIUSksCbPEAIhJJAqKGG3pvBNuCOce9Vcreq1ct5/9jRemVbsoy12pX0+1zXXpo5c2bmnl2tdfucOWfMOYeIiIiIhJ+IUAcgIiIiIoenRE1EREQkTClRExEREQlTStREREREwpQSNREREZEwpURNREREJEwpURORo2Jml5vZnFDH0ZTM7F0zm9HEx7zNzJ5pymO2RGa238x6N3VdkbZCiZpIGDGzzWZW6v3B2mlmT5hZUqjjagkOeu9qXw80Zl/n3BnOuSeDHePR8BLiZWZW4v0uPGRmqc1w3kkB71+xmbmD3tPuR3M851ySc25jU9cVaSuUqImEn7Odc0nACGAkcHOoAjGzqFCduz7mU9+/XWd7f+xrX9c0a3BNxMx+AdwN3Ai0A8YDPYAPzSymic9V5zN2zs2uff+AwV5xasB7urW+fUWk6SlREwlTzrmdwPv4EjYAzGy8mX1hZvlm9rWZTfHKTzazZQH1PjSzBQHrs81surd8k5ltMLMiM1tpZt8JqHe5mX1uZvea2T7gNjNLN7M3zKzQzOYDxwXUN6/ubm/7MjMbcrjrMbNPzezPZjbfq/u6maUd6doC9v2jmX0OlABH1T0WcF0PmFmBma02s2kHHf9H3nIfM/vMq7fXzF4IqHeCmS3wti0wsxMCtvXy9isysw+BjINiqPf6DqqXAtwOXOuce885V+mc2wxcBPQELjOzLl7rYeD7N9KLN9pb/6GZrTKzPDN738x6BNR1Zna1ma0D1h3F+3ibmb1sZs+YWSFwuZmNM7Mvveva4b3HMQH7ODPr4y0/YWYPmtnb3vs0z8yO+4Z1TzWzNd5n8Q/vvf9RY69FpMVwzumll15h8gI2A9/ylrsCy4C/eetZwD7g2/j+k3WKt54JxANl+JKDaGAXkAMke9tKgXTvOBcCXbxjXAwUA529bZcDVcC1QJS37/PAi0AiMMQ77hyv/mnAIiAVMGBg7bEOc22fevsO8Y71X+CZI11bwL5b8bXwRAHRDb13h9lWe10/996fi4ECIC3g+D/ylp8DfuPFEQec6JWnAXnA970YLvXWa9/XL4F7gFhgMlDU2Os7KNbTvVijDrPtSeA5b/kT4H8Ctv0FeNhbPhdY730eUcBvgS8C6jrgQ++a4hv4fezp1Y3y1m8DKoHp3nXEA6PxtfhFefVXAT876Fx9vOUnvOse59V/Fnj+aOvi+z0vBM7ztl3vxfWjUH+H9dKrqV9qURMJP6+ZWRGwDdgN3OqVXwa845x7xzlX45z7EFgIfNs5VwoswJcgjAa+Bj4HJuL7I7rOObcPwDn3knNuu3eMF/C1qIwLOP9259zfnXNVQAVwPvB751yxc245vmShViW+ZHAAYM65Vc65HQ1c29POueXOuWLgd8BFZhbZ0LUF7PuEc26Fc67KOVfZwHuXH/D6n4Btu4H7nK+F6gVgDXDmYY5Ria+bsYtzrsw5Vztw4kzvfXzai+E5YDVwtvnu2xoL/M45V+6cmwW8GXDMxlxfrQxgr/f+H2wHB1rq/oMvWcTMDLjEKwP4MfBn7/OoAv4EjAhsVfO253q/O0fjS+fca951lDrnFjnn5nrvyWbgEeCkBvZ/1Tk334vrWQJajI+i7reBFc65V7xt9wM7j/I6RFoEJWoi4We6cy4ZmIIvAar9w9wDuDAwEQFOBDp72z/z9pnsLX+K7w/mSd46AGb2AzNbEnCMIdTtptsWsJyJr8UisGxL7YJz7hPgAeBBYLeZPep13dXn4ONEe+c+0rUdvG99pjvnUgNe/wzYluOccwedv8thjvErfK2D881shZn90CvvQsC1Bxwjy9uW5yWggdtqNeb6au0FMuzw93919raDr0Vygpl1xveZ1wCzA873t4Bz5XrXlBVwrMa8n4dTZz8z62dmb5lvwEMhvqQw4/C7AnUTqhKgocEy9dXtEhiH97lmNyJ2kRZHiZpImHLOfYav++evXtE2fC1SgYlIonPuLm/7wYnaZxyUqHktKv8ErsHXZZcKLMf3R9x/6oDlPfi64boFlNUZ9eecu985NxoYBPTDdwN8fQ4+TiW+xONI13ZwXN9EltfyFHj+7QdXcs7tdM79j3OuC/C/wD+8+6a240uAOOgYOfhautqbWeJB22o15vpqfQmU4+vW8zPf6N8zgI+9OPOAD/B1434XX7dg7Xu0Dfjfg84X75z7IvBSD3Puxjh4v4fwtSz2dc6lALdQ9/cpGHbguzUA8Lcodq2/ukjLpURNJLzdB5xiZsOBZ/B1s51mZpFmFmdmU8ys9g/UF0B/fN2Y851zK/AlFscDs7w6ifj+0O4BMLMr8LWoHZZzrhp4Bd+gggQzGwT45xszs7Fmdrx3A3sxvvvkahq4nsvMbJCZJQB3AC975zjStTWFDsB1ZhZtZhfiu3/rnYMrmdmFAefNw/d+1Xh1+5nZd80syswuxpecvuWc24KvK/N2M4sxsxOBswMO2+jrc84V4BtM8HczO92Ltye++wSzgacDqv8H+AFwAQe6PQEeBm42s8HeNbXzrjkYkvHdL7bfzAYAPwnSeQK9DQw1s+ley+PVQKdmOK9Is1OiJhLGnHN7gKfw3SO2Dd9N4rfgS7S24Wu9ivDqFgOL8d27U+Ed4ktgi3Nut1dnJfB/XvkuYCi+e9kacg2+Lqed+Fr4/h2wLQVfC10evq6+ffhuaq/P094xduK7Uf86L64Gr+0ovGl15/x6NWDbPKAvvha8PwIX1N63d5CxwDwz2w+8AVzvnNvo1T0L+IV3nb8CznLO1XZFfhdfUpyL777Cp2oPeLTX55z7f17dv+JLguZ5+0xzzpUHVH3Du6adzrmvA/Z/Fd/0Hs973ZHL8bXGBcMv8V17Eb7fhRcarn7svPf8QuD/4fssBuFLlMsb2k+kJbK6t2yIiASHmX2KbxTkv0Jw7svxjQg8sbnPLcFnvnn1soHvOedmhjoekaakFjUREWlxvG7kVDOL5cB9cXNDHJZIk1OiJiIiLdEEYAO+ruyz8Y34PdqpRkTCnro+RURERMKUWtREREREwpQSNREREZEwdbiZr1u8jIwM17Nnz1CHISIiInJEixYt2uucyzzctlaZqPXs2ZOFCxeGOgwRERGRIzKzgx9P56euTxEREZEwpURNREREJEwpURMREREJU63yHrXDqaysJDs7m7KyslCHIi1AXFwcXbt2JTo6OtShiIhIG9ZmErXs7GySk5Pp2bMnZhbqcCSMOefYt28f2dnZ9OrVK9ThiIhIG9Zmuj7LyspIT09XkiZHZGakp6er9VVEREKuzSRqgJI0aTT9roiISDhoU4laqEVGRjJixAiGDBnC2WefTX5+fkjimDJlSsjmmevZsydDhw5lxIgRjBgxguuuu67B+m+88QZ33XXXMZ83lNcsIiLyTbWZe9TCQXx8PEuWLAFgxowZPPjgg/zmN78J6jmrqqqIigrNx1zfuWfOnElGRkajjnHOOedwzjnnNHVoIiIiLYJa1EJkwoQJ5OTkALBhwwZOP/10Ro8ezaRJk1i9ejXV1dX06tUL5xz5+flERkYya9YsACZPnsy6deuYP38+EyZMYOTIkZxwwgmsWbMGgCeeeIJzzjmHqVOnMm3aNEpLS7nkkksYOHAg3/nOdygtLQWgurqayy+/nCFDhjB06FDuvffeQ+K8/PLL+fGPf8yYMWPo168fb731ln/fG2+8kbFjxzJs2DAeeeQRAD799FMmTZrEOeecw6BBgxr9fkyZMoXrr7/e3+I4f/58/7Vcc801ALz00ksMGTKE4cOHM3nyZMB37+EVV1zB0KFDGTlyJDNnzgSo95oBPvjgAyZMmMCoUaO48MIL2b9/f6PjFBFpy2pq3DHtX1hWyZcb9rGnqJyyyuqj2requoaKqppDyvNLKtiyr/iY4gpnalELgerqaj7++GOuvPJKAK666ioefvhh+vbty7x58/jpT3/KJ598Qv/+/Vm5ciWbNm1i1KhRzJ49m+OPP55t27bRt29fCgsLmT17NlFRUXz00Ufccsst/Pe//wVg8eLFLF26lLS0NO655x4SEhJYtWoVS5cuZdSoUQAsWbKEnJwcli9fDlBvV+zmzZuZP38+GzZs4OSTT2b9+vU89dRTtGvXjgULFlBeXs7EiRM59dRT/edevnx5vSMmTz75ZCIjIwFfy+LPf/5zAEpKSliyZAmzZs3ihz/8oT+uWnfccQfvv/8+WVlZ/lgffPBBzIxly5axevVqTj31VNauXctDDz102Gveu3cvd955Jx999BGJiYncfffd3HPPPfz+97//Jh+liEhY255fSseUOCIjDn/fbUFJJV9u3Mu3BnYkKtLXdvPG19vJSIwhPiaSmKgIYqMi6ZmewOcb9nHDC0u45+IRjOuZRklFFXklFSTERLFmZxE90hNITYjhw5U72VNUTnxMFDGRRte0BApLK3ngk/Ws233gP8Y90xNIT4pl3a4ifnlaf3LySjmuQxIGvLV0B9vzSxncJYWZa/YQYZBXUglAu/hozh3Rhd4ZiXyxYR8frNzlP2b3tASGZKVw3siuzF63hxoHPdIT+Dq7gHE92/PFhn2kJkSzLKeAHumJ5O6vIDE2kvG909maW0JJRTVV1TVU1jgGdExm3e79nDKoI2cP7xK8D+kI2mSidvubK1i5vbBJjzmoSwq3nj24wTqlpaWMGDGCnJwcBg4cyCmnnML+/fv54osvuPDCC/31ysvLAZg0aRKzZs1i06ZN3Hzzzfzzn//kpJNOYuzYsQAUFBQwY8YM1q1bh5lRWVnpP8Ypp5xCWloaALNmzfLfCzZs2DCGDRsGQO/evdm4cSPXXnstZ555pj/ROthFF11EREQEffv2pXfv3qxevZoPPviApUuX8vLLL/tjWbduHTExMYwbN67BaS3q6/q89NJLAV+LYWFh4SGJ48SJE7n88su56KKLOO+88wCYM2cO1157LQADBgygR48erF27tt5rnjt3LitXrmTixIkAVFRUMGHChHpjFRFpDpXVNURHRlBSUcX8Tbmc1C+TgtJKHpuziRrnuPG0Af661TWOWev2cMJx6VRU1fDiwmxKK6rYsq+Ec0Z0YVLfTGpqHG8u3c71zy9h+oguDO7Sjq+25REXFUlsdCQrdxRSUFLBjoIyyr1WqtSEaEZ3b8/Hq3c3GOuMx+cTGWFUH2Pr2uZ9JWzeVwLA719fccj2xJhIsvNKGdA5mey8A70iBaWVPPWl79GYB+efCTGRfLxqN+8s20lsVIT/2gDe/Hp7nbrLcw7kAR+t8l1zZISREB1JRXUNby/dAfjebyVqbUTtPWolJSWcdtppPPjgg1x++eWkpqb6710LNHnyZB566CG2b9/OHXfcwV/+8hd/1yLA7373O04++WReffVVNm/ezJQpU/z7JiYmHjGe9u3b8/XXX/P+++/z8MMP8+KLL/L4448fUu/gEZBmhnOOv//975x22ml1tn366aeNOvfhHO48gR5++GHmzZvH22+/zejRo1m0aNFRn8M5xymnnMJzzz33jWIUkbbHOUeN8/0Rr6lxvPpVDmcO60xctK9noLK6hsLSSmKiIkiOiyYnv5TdhWW89lUOT83dwol9MnjiinHUOMfS7Hz+NXsTpw/pxK//u5Sk2CgKSiuJjDDuvWgEd7+3ms37Shjdoz2LtuT5Y3hlcQ55JRV0SI5ja25JvbG+tCj7kLLXlmzntSXbD1MbAv+ZzS+p5OPVu8lIimHv/gp/eUZSDMXl1VwztQ8ju6fyyGcbmbdpHxN6pzO0azvmb8pl/e79XHNyH/74zioAMpNj+eP0IXRJjef1JTkUlVXxrYEd+Xj1bkZ0a0dibBSdUuL49+ebuWBMV5ZnFzC6R3v2FVfw4cpd3HHuYFITYvwx7C+vwjlHeVUNn63Zw46CUoZktaNr+3j6dEgmJ7+UiqoaurWPZ9WOIr7alsd5o7ry4Mz1fLRyF/ddMoLsvFL6dkhiZ2EZ43ul8/ayHTggKTaS5+Zv4/ppfemZkUhSbBSV1TWUlFeTFBfF/vKqRv2eBEubTNSO1PIVbAkJCdx///1Mnz6dn/70p/Tq1YuXXnqJCy+8EOccS5cuZfjw4YwbN47vf//79O7dm7i4OEaMGMEjjzziv0+soKCArKwswHcvV30mT57Mf/7zH6ZOncry5ctZunQp4OsGjImJ4fzzz6d///5cdtllh93/pZdeYsaMGWzatImNGzfSv39/TjvtNB566CGmTp1KdHQ0a9eu9cfyTb3wwgucfPLJzJkzh3bt2tGuXbs62zds2MDxxx/P8ccfz7vvvsu2bduYNGkSzz77LFOnTmXt2rVs3bqV/v3713vN48eP5+qrr2b9+vX06dOH4uJicnJy6Nev3zHFLiItR0VVDTXO+RMt5xyrdxZx93ur+dslI1mwKZcuqfG8v2In2/NL2ZZXwtyNuXWO8YuXvmZ0j/b84tR+3PfhOuZvziXC4HCNTLPX7eW4W96hXXw0BaW+no93l++kZ3oC1c6xd38FldWOnzy72L/Pkm35nDmsMws25TKiWyqfrt3jvz/rxD4ZzFm/l5jICCqqa/j5t/qRkRzDvR+u9SdYo7qnEhlh/O6sQWzPL2NHQSlrdxWRkRTLkKx2TDguncVb8jipXyZmxvKcApblFDA0qx1Dsnz/9pZUVFFcXk1mcqy/xQ/ghOMyqKlxRAQ0ZznnMDO+P6GH/32tVXs8gG8N6lhn25ievp6fk/t38JcdrvUqKdaXriQD54/uesj2rNR4//LQru0Y2tV3zl+fPoBfndYfM2NwF19Z78ykQ84zdUDduKIjI2iX4LvedvGhfUJNm0zUwsHIkSMZNmwYzz33HM8++yw/+clPuPPOO6msrOSSSy5h+PDhxMbG0q1bN8aPHw/4ukKfe+45hg4dCsCvfvUrZsyYwZ133smZZ55Z77l+8pOfcMUVVzBw4EAGDhzI6NGjAcjJyeGKK66gpsb35f/zn/982P27d+/OuHHjKCws5OGHHyYuLo4f/ehHbN68mVGjRuGcIzMzk9dee61R1x54j9qwYcN46qmnAN9jm0aOHEllZeVhW/ZuvPFG1q1bh3OOadOmMXz4cAYMGMBPfvIThg4dSlRUFE888QSxsbH1XnNmZiZPPPEEl156qb+L+c4771SiJtJCFZdXkRgbxa7CMhZtySM1IZoTjsugqKySGY/PJ7+0ksl9MzmpXyaREcbn6/fyyKyNAMyY0IOJfTJ4+LMNLN6aD8Dw2z8AID46ktIj3Oy+aEse3/3nPAAm9E5nX3E5a3ftZ1LfDKaPyKJ/p2Sy80q49rmvqKx2/iSt1k1nDGDCcRl8uWEvibFRvL10BwWllVwxsRepCdH065jsr7u7qAznoGNKXJ1jVNc4//1n3zu+ByUVVezbX0G3tAR/nWGH5jUATAlIjoYEJGi1EmKiSIjxpQm1SVqtiIjD94AcnKSFg5Y+L6Y5d2x9zOFozJgx7uA5s1atWsXAgQNDFFHLdfnll3PWWWdxwQUXBPU8U6ZM4a9//StjxowJ6nmOhn5nRILLOceeonI6BCQfJRVVREdGEGFGZIRRVlnNk19s5q2lO7h0XHey80rYX15Fdl4pURHGByt38evTB/DQp+spLPN1UcVFR9AxJY4t++rvImxIYMvYpL4ZzF63lyeuGMvEPhl8vS2fP7y1kopqx5Un9uLOt1dy29mDmT7S16OwPb+UTilxdRKZmhpHaWU1MVER5JdUUl5VzWdr93Dp2O6HJDzSNpnZIufcYf8AqkVNRESazBtfb+errXlcN7Uv7RNjqK5xRJivVeNP76xiVPdUThvcicLSKq57/is+W7uHN685kT+9s4r95VUUl1excW8x8dGR/HTKcTy/YBs5+b4byZe9uuyw57z7vdV11ssqa9hZUMal47rz3PytdbadNyqLn03rx+S/+KbyGdQ5hbE923PLmQOZvXYvBaWVTO6Xyfrd+/ls7R6un9aXfcXldG3va6Ea0zON16858cDxRmbVSba6BHTB1YqIMBK9rrvM5FjA1/ol0hhqUROph35npK1yzrE8p5CeGb7kJDmu/nt03vx6Ows253LJ2O5c85/FbNx76HxWN5zSjw9W7vSPskuJi/K3fgFERxqV1Y60xBhyiyvq7JuaEM09Fw2nc7t4nvpyM2WVNUzul8GwrqlkJMWycc9+5m/KZUhWO3pnJvLRyl1MG9iRtMQYYqMieH/FToZ3S2XD7mL6dUzyt96t8+7Xap8Yg0ioNdSipkRNpB76nZHWzjlHdl4p3dIS2LBnP7FREXRtn8CTX2zm1jd80yV0S4vn7vOHERcdyVVPLWJg52SKyqpITYjmhlP6cc4Dnx/VOXtnJrJxjy+Z+9slI4gw4/Y3VzBtQEfumD6Ybbkl9OmQTG5xBU98vomzh3ehb8C9WiKtkbo+PbWjUkSOpDX+B0bappKKKjbuKebvn6zjzGFdOGd4F/+M8Nf8ZzEfrdrNXy4Yxm9fW055VQ2zf3Vyne7Cbbml/hvmAWavK/cvf7pmDwBP/XAcP3jc9zSRuTdP47E5G/nn7E387qxBnDm0M68tyaF7WgKnDe6EAc8v2Mbwbu38o/ACR9/16eBLytISY7jh1P7BeVNEWpA206K2adMmkpOTSU9PV7ImDXLOsW/fPoqKihqcuFcknJRVVvPe8p2c2DeDLfuK+fEzi2kXH01GUkydqSWSYn3zQp05rLN/Qs+G/Od/jmfh5jw+XbObr7MLqK5x/ObbA4mIMP7w1koANv7p29z30Vo+W7uH1685kZoaR0V1TViOABQJR+r6BCorK8nOzqasrCxEUUlLEhcXR9euXYmODu38OSKB9hSVc8mjX3LX+cMorahmUJcUfv/6ctITY3l6rm+m9sFdUthZUMa+g+71qs/kfpnMWruHzORYvnd8d+77aB0Avzy1Hx1T4rhwTDd/3bziCsqraujUznef1/b8UnKLKw6Z1kFEjo66PoHo6Gi1johI2CmrrCYywoiOjGB/eRXPzN3C2J5pjOiWSoTBV9vyuffDtazdVcSuQl+344UPf1nv8VZ4j8d78LujyCup4ONVuzhlUCcm9c1g1Y5C8ksreXbuFjqmxHHdtL5kpcbzxBebOWNoJwZ0SqGwtIqU+Ciumdr3kGMffON9l9T4w45yFJGm02Za1EREwo1zjuG3f8C4XulcffJxfOcfX/i3TR/RhbjoSJ5fsK3e/ft3TGbNriLAN81E78xE0hJj2F1Yzj++N0pzdIm0EGpRExEJgsYOUJq5ejf//mIz918ygi837OOZeVvomppARnIMhWVVfLRqF7uLDtyWMbxbqv/ZjBeN6UpaYix9OiRR4xw4+GDlTm48bQD9OyVTVV1DRXWNfwZ5EWld9M0WEfkGNu0t5lv3fMa/Zoyp85xCgPmbcvn7J+v41sCOLMsp4GXvQdl3v7cmYETlvjr7LM0uICUuivm/+Rbrdu3n7AfmAPCn7wwl6qDH91w09sB9Y1GREYdsF5HWQ4maiMhBSiqqMIz4mEjW7CziuMxEnvhiM3M37mPNriJm3XgyD85cT3WN4/WvchjVrT0REbA9v4z/eWohW3N9jy6avW5vneMGTnvx4c8nM3vdXgZ0TiY7r5T3l+/kykm9iIuOZGjXdtx69iBioyKVhIm0cbpHTUTEU1FVA8CUv8wkOiqCO84dwgxvfrBAY3u2Z8HmvKM69u3nDObWN1aQnhjD7F+frK5KEfHTPWoiIkews6CM6Q9+TmSEsb3Ad7/YiwsPfyN/bZI2olsqS7blA9AuPpremYncdd4w+nVM4tM1e3hm7hZ+e9YgPlm9mx9M6MHQru3ISo1XkiYijaYWNRFpk/KKK4iLjiQ+JpLdRWW8tDCbv7y/ptH7P33lOMb2TGPx1jxyiys4a1iXI+8kInIYalETkTZrZ0EZW3NL6JWRSExkBPExkUQYHP/nj+mdkcjzV41n3B8/BnytYnefP4yYKCM+OoqbX1nKZeN7UFXj+w/tmp1F/OLUfnRtn+A//gnHZYTkukSkbQhqomZmPwd+BDhgGXAF0Bl4HkgHFgHfd85VmFks8BQwGt9wqIudc5u949wMXAlUA9c5594PZtwi0vLNWruHz9bu4bE5m+qts3pnESfc9Yl/fVDnFE4f0sm//umNJwc1RhGRIwlaomZmWcB1wCDnXKmZvQhcAnwbuNc597yZPYwvAXvI+5nnnOtjZpcAdwMXm9kgb7/BQBfgIzPr55yrDlbsItIy1M5jVl3jmLVuD3PW7SUtMYaR3VL9DwmvT0xkBMf3TqszMvOs4Z2DHbKIyFEJdtdnFBBvZpVAArADmAp819v+JHAbvkTtXG8Z4GXgAfPNJHku8LxzrhzYZGbrgXFA/c9QEZFWb+X2Qr59/2zOH9WV/y7Orrfe3y4ZwdLsAh6bs4mOKbGcPawLvzp9AA5HTGQEW3NLyEiKZeGWPCb3VTemiISXoCVqzrkcM/srsBUoBT7A19WZ75yr8qplA1nechawzdu3yswK8HWPZgFzAw4duI+fmV0FXAXQvXv3Jr8eEWle1TWOyAhj/qZcFmzOpVdGImcM6UR+SSUj//Chv97hkrROKXH07ZjE2J5pnDO8C+eOyOKHJ/YiNT6axNi6/+z1SE8E4KR+mcG9IBGRbyCYXZ/t8bWG9QLygZeA04N1Pufco8Cj4Bv1GazziEjwrdhewJn3z+EXp/Tj/z5c6y//3VmD6Nb+0IeAx0ZFkBwXzd8vHcmE49IPe8wsPTxcRFqgYHZ9fgvY5JzbA2BmrwATgVQzi/Ja1boCOV79HKAbkG1mUUA7fIMKastrBe4jIi1QRVUNCzfnckKfDHYXlhEbFUm7hGjKq6r53WvL+XjVboA6SRrAH95a6V9+9/pJ5JVUaNSliLRqwUzUtgLjzSwBX9fnNGAhMBO4AN/IzxnA6179N7z1L73tnzjnnJm9AfzHzO7BN5igL9DwXcIiEtb+78M1PPLZRv77kxM4/6Ev6JWRyAWju/Lhyl3+CWQbMr53GgM7pwQ/UBGREAvaQ+Scc/PwDQpYjG9qjgh8XZO/Bm7wBgWkA495uzwGpHvlNwA3ecdZAbwIrATeA67WiE+RlmNnQRnPzN1CcXkVs9ftwTnnbzF74JN1gO8B5395f02dJC0hJpLZvzp0eowzh3Xm+asmNEvsIiKhpicTiEiTc87xm9eWc9bQztz93mq+zi7grGGdeWvpjgb3G9ApmW8N7MibS7dz42n9OWtYF5xzvL9iF9MGdiBaDygXkVaooScTKFETkSaXnVfCiXfPJCYqwv+g86gI88/wD3Dh6K68tCibvh2S+N7x3emRkcjJ/TuEKmQRkZDRI6REpMntL6+isLSSHQVlfLU1jx9N6s3cjfu44YUl/oea1yZpAFU1jsn9Mlm5vZCzhnWmqzd6c0r/TC6f2Csk1yAiEu6UqInIN3Lpo3NZllNAclwURWVVFJVVMXfjPn+SVqt/x2QykmP4fP0+JvfN4N+XjyXCoLCsitjoSC4Z262eM4iIiBI1EWmUNTuL6NcxiafnbmFnQRnLcgoAKCrzzV/9t4/X1amfHBtFUXkV547swvmjuvL+ip187/geREYY4HsA+vfH92jeixARaWGUqInIEdU+rungAQHx0ZH0ykhkSv9M/vHphjr73DF9MO8t38kPJ/YiLjqSH0zo2cxRi4i0fErUROSIaqfNCEzSjstM5ONfTAFgWXYB//h0A4kxkfzpvKH8c/ZGpo/I4jsju4YgWhGR1kNj3UXksHLyS5l41yfMXLObt5ZuP2T75IBnYx7Xwfe8zB9N6s25I7J469pJmFmzxSoi0lqpRU1EAFi3q4hzHvicN6+dSH5JJQ9/toGc/FKu+PcCAKYN6MDHq30T1b74vxMY0S3Vv29CTBSr7jiduGj9309EpCkpURNpA5xzFJVXsaeonFtfX8HAzsn8+vQBvLt8J3HRkbyzbAefrN5NaWU137pnFumJMewrrvDvP65XGv+aMYbT75tNZIQxrlfaIeeIj4lszksSEWkTlKiJtAH/+HQDf3l/Db0zE9m4p5g56/dy8oAOXPvcV4etH5ikAUzonY6Z8c71k6iqqTnsPiIi0vSUqIm0Aa8szgZ8z9Ss9d1/zmtwn4cvG8XkfpnMXL2HUwd3BCAywoiMUMuZiEhz0Q0lIq3cttwSNuzxJWiHe2Jc53ZxnDLIl4j175hM7RiAaQM7khATxZnDOusZmyIiIaIWNZFW4o2vtzOwUzJ9OyazdV8JHdvFsmBTHpc91nDL2QtXTaB7egJz1u0lIzmG+Ghfi5mSMxGR0FOiJtIK7NtfznXe/Wbr/ngGk/8yk0GdU4g4TK71y1P7kZkcy+Au7UiIiaR7egIAJ/bNaM6QRUSkEZSoibQCW3JL/MurdhQCsNL7GSgmMoJrpvZttrhEROTYKFETaeFKKqrYuu9AorZgc94hdeKjIxnTsz13nT+sOUMTEZFjpERNpAVyzvHEF5vpmZHIFf9eQJd2cf5tD85cD8D3x/fg6blbAFj1h9NDEqeIiBwbJWoiLczLi7J59atsPl+/z1+2vaDMv5xbXEFyXBS/P3sQT8/dwiTdeyYi0mJpWJdIC/PW0u11krRa103t41/ukBxLdGQEM385hYcuG92c4YmISBNSoibSQuwoKMU5x9aAgQPgezj67F+dzJUn9vaX1SZnvTISSYpVw7mISEulf8FFwlx2XgnzN+Vyw4tfc+vZg8jOLa2zvabG0S0tAeccl47rzgWjs+jXMTlE0YqISFNSoiYSpj5YsZPSympeWLCNLzb4ujrv+XAtFdV1n7XZ2RtIYGb8+byhzR6niIgEjxI1kRD7vw/W0D4hhh+e2AuAOev28snq3Tz++SYA4qIP3KFQVFZFhMGb156IYewqKmNMj/YhiVtERIJPiZpIiP39E990GheP7cbS7IJDHvlUVlm3Be3yE3oxuEs7AAaR0jxBiohISChRE2lmW/eVcN9Ha/n1GQOorjnwlPTBt75f7z4v/3gCPTMSyS+poHdGUnOEKSIiYUCJmkgzcc5RWFbFo7M38MpXObzyVU69dft0SGL97v0AnDcqizE90wDISIptllhFRCQ8KFETaQaV1TU8M3cLt7+5kvNGZR2y/YWrxnPxo3P967d8ewAbdhczoHMyJxynCWtFRNoqJWoiQVZYVsmw2z7wr7+y+NCWtNoWs1oT+2QwdUDHoMcmIiLhTYmaSJAFJmn1iYwwHvjuSDbvLeZbgzoSGxXZDJGJiEi4U6ImEkRFZZUNbjeD747rDsBZw7o0R0giItKCKFETCZKrn13M28t21Cn79tBOvLNsJwDvXDeJQV00vYaIiNRPiZpIE/ls7R7eWLKdv144jGG3fUBReVWd7Sccl85Pp/Th3BFZZKXGK0kTEZEjUqIm0kRmPD4fgO35pf4kLSUuisIy3/Id5w6hT4ckhmS1C1mMIiLSsihREzlGb369nRcXbvOvf7nR91zO6Ejj85um8upXOazIKaRXRmKoQhQRkRZKiZrIUSqvquaqpxZxwyn96NcxmWuf++qw9T7/9VSS46L5wYSezRugiIi0GkrURI7Sul37+WztHrbsK6Z9Yoy/fEhWCkmxUczdmAtAZrKeIiAiIsdGiZrIUcotrgBg874SNu8rAXxJ2lvXTqKgpJLhd/jmTTOzkMUoIiKtgxI1kaO0q7DskLJxPdMBSImP4rLx3TlzqOZEExGRY6dETaQB23JL6No+HjNj4eZcnp67hejIiDp1PrrhJLqlxQO+VrQ7pw8NRagiItIKKVETqcfM1bu54okFPHzZaPYVl/ObV5f7t7WLj2beLdPYX15FRpLuRRMRkeCIOHIVkbbp2XlbAdi0t5iXFmbTuV0ck/tlAnD28M7ERUcqSRMRkaBSi5rIYeQVVzBr3R4A8ksqWLOziIvHduOGU/uxcnshY3umhThCERFpC5SoiQAvLdxGbHQk5wzvwnvLd/DjZxb7tz0yayMAgzqnkBIXzfje6aEKU0RE2hglaiLAjS8vBeCc4V340zurD1vn5AEdmjMkERERJWoiW7250ADeW76Trbm+9UGdU/je+O489cUWZpzQUxPYiohIszPnXKhjaHJjxoxxCxcuDHUY0kL0vOntQ8ruv3QkZw7tTGSEJq0VEZHgMrNFzrkxh9sW1FGfZpZqZi+b2WozW2VmE8wszcw+NLN13s/2Xl0zs/vNbL2ZLTWzUQHHmeHVX2dmM4IZs7QdldU1fLBip399QKdkYqMiOHdEF04d1FFJmoiIhFywuz7/BrznnLvAzGKABOAW4GPn3F1mdhNwE/Br4Aygr/c6HngION7M0oBbgTGAAxaZ2RvOubwgxy6tiHOOwrIq2sVH+8vu/3gdf/9kvX/9fyb15rxRWXr0k4iIhI2gtaiZWTtgMvAYgHOuwjmXD5wLPOlVexKY7i2fCzzlfOYCqWbWGTgN+NA5l+slZx8Cpwcrbml99u4v58KHv2T47R+wemchZZXVvLd8J19nF9Spl5kcqyRNRETCSjBb1HoBe4B/m9lwYBFwPdDRObfDq7MT6OgtZwHbAvbP9srqK6/DzK4CrgLo3r17012FtHg3v7KMhVt8DbDPzdtKelIs93y4tk6df18+1j+ZrYiISLgI5j1qUcAo4CHn3EigGF83p5/zjWRoktEMzrlHnXNjnHNjMjP1B1cOyC+p8C/n5JeRF7BeS1NviIhIOApmopYNZDvn5nnrL+NL3HZ5XZp4P3d723OAbgH7d/XK6isXadBvXl3Ghyt3kRx34L60vfvL2V1UDsBd5w1l6oAOXDK2W32HEBERCamgdX0653aa2TYz6++cWwNMA1Z6rxnAXd7P171d3gCuMbPn8Q0mKHDO7TCz94E/1Y4OBU4Fbg5W3NI6FJRU8uy8rTw7bysT+xx4ksCSbfks2ZbPiG6pXDKuO5eMUze5iIiEr2CP+rwWeNYb8bkRuAJfK96LZnYlsAW4yKv7DvBtYD1Q4tXFOZdrZn8AFnj17nDO5QY5bmnh1uwq8i9/vn4f43un0a9jMk99uQWAy0/oGaLIREREGi+oiZpzbgm+aTUONu0wdR1wdT3HeRx4vEmDk1YtMFEDGNg5hcQY36/7xD7pTB95yHgUERGRsKNHSEmrsaOglK+35TO6RxoPfrKe5NgoendIIj0xhuun9WWRN/Lz+mn9QhypiIhI4yhRk1bh41W7uPJJ32PDUhOiyS+pJCMpltevnuivM21gR1b/4XTioiNDFaaIiMhRCeojpESaS22SBpBfUglARlLMIfWUpImISEuiFjVp8VZuLzyk7OYzBnDGkM4hiEZERKTpKFGTFqumxnHn26tYsq3uY1/vOm+opt0QEZFWQYmatFgb9uzn8c83AXB8rzRuPXswPdITSIzVr7WIiLQOukdNWpTyqmp++MQClmUX8PdP1vvL+3ZMYlCXFCVpIiLSquivmrQYzjnW797PJ6t388nq3XW2ndgnI0RRiYiIBI8SNWkRdhWWcfyfPmZEt9Q65Q98dyRnDesSmqBERESCrN5EzcxuaGhH59w9TR+OyOGt370f8D2rs9ZPpxynJE1ERFq1hlrUkr2f/YGx+B6aDnA2MD+YQYnUuvGlr9m7v/yQRz7df+lIThvcMURRiYiINI96EzXn3O0AZjYLGOWcK/LWbwPebpbopE1zzvHSomwAxvVKr7Pt20M6ERWpsTAiItK6NeYvXUegImC9wisTCQrnHB+v2sWGPcX+sq25xSTHHfh/hZI0ERFpCxozmOApYL6ZveqtTweeCFZAIu8u38lPn11MZnKsv+yFBdsY0yONG0/vz6aABE5ERKQ1azBRMzPDl6i9C0zyiq9wzn0V7MCk7fo6Ox+APUXl/rIaBzNO6MnYnmmM7ZkWoshERESaV4OJmnPOmdk7zrmhwOJmiknamMrqGl5fsp3zRmYREWEs2Zp/SJ2OKbEaPCAiIm1OY7o+F5vZWOfcgqBHI23S43M28ed3VwNwweiubNizn4vGdOXFhb6BBPN/M43YyEjdlyYiIm1OYxK144HvmdkWoBgwfI1tw4IambQZ+4p9Y1X2FJVz2xsr2Lu/guMyk/zbOyTHhSo0ERGRkGpMonZa0KOQNi0ywgD4els+763YCcBxmUmM6JZKdl5JKEMTEREJqSMmas65LQBm1gFQ04Y0uUjzJWq1SVrvzEROHtCBqQM6hDIsERGRkDviTT9mdo6ZrQM2AZ8Bm/GNAhU5Zne9u5oHZq6vU3bh6G5ERhgR3ktERKStaszd2X8AxgNrnXO9gGnA3KBGJW1CaUU1D3+24ZDyquqaEEQjIiISfhqTqFU65/YBEWYW4ZybCYwJclzSBszbtO+QsgGdkjl/dNcQRCMiIhJ+GjOYIN/MkoBZwLNmthvf6E+RRnPO8T9PLcTMuGpyb8b2TGN7flmdOn/6zlC+e3z3EEUoIiISfhqTqJ0LlAI/B74HtAPuCGZQ0vqs3FHIR6t2A/Dhyl288tMT2Lu/vE4dJWkiIiJ1NSZRuwSY5ZxbBzwZ5HiklVm8NY+uqfEsPuhpA9c//xXbcktJjovitrMHkxgbGZoARUREwlhjErXuwCNm1gtYiK8LdLZzbkkwA5PW4bx/fEFGUiwzJvSoU74ttxSAorIq3ZMmIiJSjyMOJnDO3eqcmwoMAmYDNwKLgh2YtHxlldUA7N1fTn5pJXHRegSUiIjI0WjMPGq/NbN3gQ+APsAvATWByBHtKTpwD9pjczaRGONrwE1NiGb6iC4AXDetb0hiExERaQka0/V5HlAFvI1vwtsvnXPlDe8icuAZnoHrn904haTYKNKTYrnvkpEhikxERKRlaMwjpEaZWQowETgFeNTMdjvnTgx6dNKi7S06NJ/vkZ4YgkhERERapiMmamY2BJgEnIRvottt+O5VE2nQbi9Ri42KoLxKTxsQERE5Wo25u/suIAW4HxjonDvZOff74IYlLd2Sbfn8+d1VZKXGs+L20wC4UKM7RUREjkpjuj7PMrN4oLtzrrIZYpIWrLCsknW79jNz9W6Kyqp44oqxREVGsPmuM0MdmoiISIvTmFGfZwNLgPe89RFm9kaQ45IWZEdBqf9B6j97fgnnP/QF8zfn0rldHKN7pIU4OhERkZarMaM+bwPGAZ8COOeWeJPfilBWWc2EP39C1/bxTOmfydLsAgDmb8qlb4ekEEcnIiLSsjXmHrVK51zBQWUuGMFIy1M7BUd2XinPzN1aZ9u2vJJQhCQiItJqNKZFbYWZfReINLO+wHXAF8ENS1qCvfvLD5mCI7/kwNxpJxyX0dwhiYiItCqNSdSuBX4DlAPP4btX7Q/BDErCX15xBWPu/IghWSl1yqtqHGcO7czPT+lHp3ZxIYpORESkdWjMsz5LnHO/cc6Ndc6NAZ4GHgh+aBLOthf4Hqq+PKfwkG39OibTp0MSSbGN+X+AiIiI1KfeRM3MhpnZB2a23MzuNLPOZvZf4GNgZfOFKOFod2HdLs+LxhyYI61jSmxzhyMiItIqNdSi9k/gP8D5wF58U3RsAPo45+4NfmgSznYUlPmXIwzuOm8YfbxRnh3V5SkiItIkGkrUYp1zTzjn1jjn7gOKnXO/cs6VNbCPtBE7va5PgKFdU4mIMLq2jwegY7ISNRERkabQ0E1EcWY2EjBvvTxw3Tm3ONjBSfjKzjuQqNV2e2al+hI1DSIQERFpGg0lajuAewLWdwasO2BqsIKS8FZUVsnnG/YCMKhzCheO7gbApL4ZrNu1n/YJ0aEMT0REpNWoN1Fzzp3cnIFIeKuucdQ4R3RkBD95ZjG7CsuZPqIL910y0l/n9CGdOX1I5xBGKSIi0ro05skEx8TMIs3sKzN7y1vvZWbzzGy9mb1gZjFeeay3vt7b3jPgGDd75WvM7LRgxyyHmvH4fPr99l2cc8xZ72tNS0vU6E4REZFgCnqiBlwPrApYvxu41znXB8gDrvTKrwTyvPJ7vXqY2SDgEmAwcDrwDzOLbIa4JcCc9XtxDnrd/A4A00d04een9A1xVCIiIq1bUBM1M+sKnAn8y1s3fPe2vexVeRKY7i2f663jbZ/m1T8XeN45V+6c2wSsx/eQeAky5xwfrtzF/E25dcoHdErm/y4aQXKc7kUTEREJpnrvUTOzUQ3t2MhRn/cBvwKSvfV0IN85V+WtZwNZ3nIWsM07dpWZFXj1s4C5AccM3Ccw3quAqwC6d+/eiNCkIQUllczbtI+rnl5Upzw+OpL3fjY5RFGJiIi0LQ2N+vy/BrYdcdSnmZ0F7HbOLTKzKUcf2tFxzj0KPAowZswYF+zztXYT7vqYkorqQ8rTEmNCEI2IiEjbFMxRnxOBc8zs20AckAL8DUg1syivVa0rkOPVzwG6AdlmFgW0A/YFlNcK3EeCpDZJG9g5hS37iv3rqZp6Q0REpNk06h41MxtiZheZ2Q9qX0faxzl3s3Ouq3OuJ77BAJ84574HzAQu8KrNAF73lt/w1vG2f+Kcc175Jd6o0F5AX2B+I69PjlFWahwf3XASL1w1HoBfnNovxBGJiIi0HQ11fQJgZrcCU4BBwDvAGcAc4KlveM5fA8+b2Z3AV8BjXvljwNNmth7IxZfc4ZxbYWYv4nsQfBVwtXPu0D45aTJV1TX+5ZioCLqkxtMlNZ7Nd50ZwqhERETaniMmavhat4YDXznnrjCzjsAzR3MS59ynwKfe8kYOM2rTe4bohfXs/0fgj0dzTjl6zjm+3LiP3hlJ/rJ28bonTUREJFQak6iVOudqzKzKzFKA3dS9Z0xaiTeX7uC6577i0nG+UbNd28dz42n9QxyViIhI29WYRG2hmaUC/wQWAfuBL4MZlITGht37AXhu/lYiDF6/eqJGeYqIiITQERM159xPvcWHzew9IMU5tzS4YUko1LgDs5qM6JZKepIeESUiIhJKRxz1aWYf1y475zY755YGlknrsXd/hX/5+N7pIYxEREREoOEnE8QBCUCGmbUHzNuUwmGeDCAtz9g/fkS39vG88tOJAGzPL/VvG9czLVRhiYiIiKehrs//BX4GdAECHxdVCDwQxJikmewpKmdPUTkb9uzn0kfnsruoHIAhWSmc1C8zxNGJiIhIQ08m+BvwNzO71jn392aMSZrZFxv2+ZO0ey4azndGZmFmR9hLREREgq0xoz4fMbPrgNoncX8KPOKcqwxaVNKsfvfacgB+fNJxnD6kk5I0ERGRMNGYRO0fQLT3E+D7wEPAj4IVlASfc3WfW9+lXRw3nTEgRNGIiIjI4TQ0mKD2weljnXPDAzZ9YmZfBz80Cabyqpo661MGdAhRJCIiIlKfhqbnqH3webWZHVdbaGa9AT1rs4W75dVl/uUbT+vPn74zNITRiIiIyOE01PVZe6PSL4GZZrbRW+8JXBHMoKTpbd1XQkp8FNvzy7jtzRXM35Tr3zZec6aJiIiEpYYStUwzu8FbfgSI9JargZHAzGAGJk1r8l9m0ikljgGdk+skaX/8zhBG92gfwshERESkPg0lapFAEgda1gL3SQ5aRBI0OwvLOHhAZ1ZqfGiCERERkSNqKFHb4Zy7o9kikaApqzxwS+GOgjJ+9q2+3PfROgAqq119u4mIiEiINTSYQJNptRIFpXWnvLvyxF789syBAKQlxoQiJBEREWmEhlrUpjVbFBJUgYlaTGQESbFRXHliL8b3TmdIVrsQRiYiIiINaegRUrn1bZOWZfGWPP9y+8Ro/5MHlKSJiIiEt8Y8mUBaqLLKahZuzuOmVw7MmZaWGBvCiERERORoKFFrpYrLqxh86/uHlKclRocgGhEREfkmGhpMIC3YK1/l+JePy0z0T8MRH63cXEREpKVQotbKLM8p4LY3VtS5L+33Zw/m3BFdADjhOD2FQEREpKVQ80or879PLyInv5T46Eh/Wfe0BAZ0SiYqMoLLxvcIYXQiIiJyNJSotVKlldVcc3IfOqTE0jM9ATPjhlP6hTosEREROQpK1FqRbbklREcemKf456f0IzJC8xaLiIi0VErUWoG84go27NnPBQ9/6S87e3gXJWkiIiItnBK1VuAHj89nWU6Bf/3s4V2496LhIYxIREREmoJGfbYCgUkaQK/0BKIi9dGKiIi0dPpr3gplpsSFOgQRERFpAur6bMFyiytYs7PokPLMJD0mSkREpDVQotaCfe9f81i1o/CQ8g4pStRERERaA3V9tmCHS9JALWoiIiKthRK1FiwxJvKw5ZnJStRERERaAyVqLVhqQswhZY9+fzRx0YdP4ERERKRlUaLWgqUlHpqoHd9bD10XERFpLZSotVCV1TWUV1WTEBPJ/Fum0cHr7qyvO1RERERaHo36bKGu+c9i1u7az+mDO9EhJY7//uQEFm3J00S3IiIirYgStRbq/RW7APzP8+yWlkC3tIRQhiQiIiJNTM0vLVxReVWoQxAREZEgUaLWghSVVeKcq1O2v6wyRNGIiIhIsKnrs4XIzivhxLtncuf0ISzakucv368WNRERkVZLiVoL4Jzj620FAPz2teUAjOnRnoVb8ujbMTmUoYmIiEgQKVELc29+vZ1fvvQ1Q7La+cs6pcTx/FXjWbItn4GdU0IYnYiIiASTErUw99SXmymvqqnT3TkkK4WoyAjG9EwLYWQiIiISbBpMEOa255f5l3tnJgLQKyMxVOGIiIhIM1KLWpjaU1ROYVkl2wtK/WXXTu1DakIM49SSJiIi0iYELVEzs27AU0BHwAGPOuf+ZmZpwAtAT2AzcJFzLs/MDPgb8G2gBLjcObfYO9YM4Lfeoe90zj0ZrLjDxZS/zKS4ohqAP5w7mP6dUhjdo71/glsRERFp/YLZ9VkF/MI5NwgYD1xtZoOAm4CPnXN9gY+9dYAzgL7e6yrgIQAvsbsVOB4YB9xqZu2DGHdYqE3SEmIimT4yi3G90pSkiYiItDFBS9SccztqW8Scc0XAKiALOBeobRF7EpjuLZ8LPOV85gKpZtYZOA340DmX65zLAz4ETg9W3OFm+sgskuOiQx2GiIiIhECzDCYws57ASGAe0NE5t8PbtBNf1yj4krhtAbtle2X1lR98jqvMbKGZLdyzZ0/TXkAzq6iq8S//ePJxIYxEREREQinoiZqZJQH/BX7mnCsM3OZ8z0Nyh93xKDnnHnXOjXHOjcnMzGyKQ4bM7iLfSM+7zhtK93Q9aF1ERKStCmqiZmbR+JK0Z51zr3jFu7wuTbyfu73yHKBbwO5dvbL6yluthZt9c6ZltY8PcSQiIiISSkFL1LxRnI8Bq5xz9wRsegOY4S3PAF4PKP+B+YwHCrwu0veBU82svTeI4FSvrFVanlPAz15YAkB/PR5KRESkTQvmPGoTge8Dy8xsiVd2C3AX8KKZXQlsAS7ytr2Db2qO9fim57gCwDmXa2Z/ABZ49e5wzuUGMe6Q2ppb4l/OTI4NYSQiIiISakFL1Jxzc4D65pOYdpj6Dri6nmM9DjzedNGFr9ziCgDOG5mFr1FSRERE2io9QirMbNpbjBn8vwuGhToUERERCTE9QiqMLM8p4LE5mwCIilQOLSIi0tYpUQsTX2/L58kvNoc6DBEREQkjStTCxLkPfu5ffvKH40IYiYiIiIQLJWohVlldw0sLs/3ro7qnclK/lj1hr4iIiDQNJWohNmfdXm55dRkAk/tlcu9Fw0MckYiIiIQL3bEeYjn5pQBkpcbz/84fRnqS5k4TERERH7WohVBBaSUb9xQTYfDZjVM00lNERETqUKIWIhVVNQy//QMAOiTHKkkTERGRQyg7CJFP1+z2L2eou1NEREQOQ4laiKzbvd+/PLhLSggjERERkXClrs8Q2bBnPx2SY7nv4hGM65UW6nBEREQkDClRC5ENe4rp0yGJE/pkhDoUERERCVPq+gyBv7y/mq+35TOos7o8RUREpH5K1ELgwZkbABike9NERESkAer6bEan3zeL1TuL/OuT+upRUSIiIlI/tag1E+dcnSTtvotHkJmsaTlERESkfkrUmklhaVWddc2dJiIiIkeiRK2ZrN5Z6F9OjotibK/2IYxGREREWgIlas2gusZx8aNz/et/vXA4sVGRIYxIREREWgIlas1g3qZ9ddbH9FBrmoiIiByZRn02g8fnbCY1IZovbppKQozechEREWkctag1gwWbczlzaGclaSIiInJUlKgF2W1vrKCgtJKOKXGhDkVERERaGCVqQZRXXMETX2wGNB2HiIiIHD0lakEUOIggPSkmhJGIiIhIS6RELUjeW76THz+z2L+eoURNREREjpIStSD57WvL6qxrIIGIiIgcLWUPQVBZXcPe/RX870m9uXRsd578cjP9OiaHOiwRERFpYZSoBUFecQUAXdsn0DMjkVvPHhziiERERKQlUtdnEOzd70vUMhJ1X5qIiIh8c0rUmtBHK3dx+n2z2FVUBkC6puQQERGRY6Cuzyb0u9eXs6OgjCv+vQDQlBwiIiJybNSi1oS6pSXUWc9MVouaiIiIfHNK1JpQYWmlf/msYZ1JiYsOYTQiIiLS0ilRa0I5+aX+5dMGdwphJCIiItIaKFFrIgWllRSVVfnX0zTiU0RERI6RErUmsi23pM56+wQlaiIiInJslKg1gaKySs76+5w6Ze0TdX+aiIiIHBslasegsrqGgtJKXlmc4y+7YmJPQC1qIiIicuw0j9ox+NnzS3h72Q4uHtMNgO+P78HvzxrE784cRESEhTg6ERERaemUqB2Dt5ftAGDNriJGdU/lD9OHAGDK0URERKQJqOuzCSzLKaD7QZPdioiIiBwrJWpNoLrGKVETERGRJqdErYkM65oa6hBERESklVGi9g1VVtfUWR/do32IIhEREZHWqsUkamZ2upmtMbP1ZnZTqOO558O1ddbb60kEIiIi0sRaRKJmZpHAg8AZwCDgUjMbFMqYFm3O8y/fff7QEEYiIiIirVVLmZ5jHLDeObcRwMyeB84FVoYqoNjoCEZ0S+W1qyeGKgQRERFp5VpEixqQBWwLWM/2yvzM7CozW2hmC/fs2RP0gPburyAjSd2dIiIiEjwtJVE7Iufco865Mc65MZmZmUE/37795aQnxgb9PCIiItJ2tZRELQfoFrDe1SsLiZoaR25xBelqURMREZEgaimJ2gKgr5n1MrMY4BLgjVAFU1hWSVWNIyNJLWoiIiISPC1iMIFzrsrMrgHeByKBx51zK0IVT1JsFO9eP0ktaiIiIhJULSJRA3DOvQO8E+o4AKIiIxjYOSXUYYiIiEgr11K6PkVERETaHCVqIiIiImFKiZqIiIhImFKiJiIiIhKmlKiJiIiIhCklaiIiIiJhSomaiIiISJhSoiYiIiISppSoiYiIiIQpJWoiIiIiYcqcc6GOocmZ2R5gSzOcKgPY2wznkcbTZxKe9LmEH30m4UmfS/hpjs+kh3Mu83AbWmWi1lzMbKFzbkyo45AD9JmEJ30u4UefSXjS5xJ+Qv2ZqOtTREREJEwpURMREREJU0rUjs2joQ5ADqHPJDzpcwk/+kzCkz6X8BPSz0T3qImIiIiEKbWoiYiIiIQpJWrfgJmdbmZrzGy9md0U6njaEjPrZmYzzWylma0ws+u98jQz+9DM1nk/23vlZmb3e5/VUjMbFdoraL3MLNLMvjKzt7z1XmY2z3vvXzCzGK881ltf723vGdLAWzEzSzWzl81stZmtMrMJ+q6Elpn93Pu3a7mZPWdmcfquND8ze9zMdpvZ8oCyo/5umNkMr/46M5sRjFiVqB0lM4sEHgTOAAYBl5rZoNBG1aZUAb9wzg0CxgNXe+//TcDHzrm+wMfeOvg+p77e6yrgoeYPuc24HlgVsH43cK9zrg+QB1zplV8J5Hnl93r1JDj+BrznnBsADMf3+ei7EiJmlgVcB4xxzg0BIoFL0HclFJ4ATj+o7Ki+G2aWBtwKHA+MA26tTe6akhK1ozcOWO+c2+icqwCeB84NcUxthnNuh3NusbdchO8PTxa+z+BJr9qTwHRv+VzgKeczF0g1s87NG3XrZ2ZdgTOBf3nrBkwFXvaqHPyZ1H5WLwPTvPrShMysHTAZeAzAOVfhnMtH35VQiwLizSwKSAB2oO9Ks3POzQJyDyo+2u/GacCHzrlc51we8CGHJn/HTIna0csCtgWsZ3tl0sy8boCRwDygo3Nuh7dpJ9DRW9bn1TzuA34F1Hjr6UC+c67KWw983/2fibe9wKsvTasXsAf4t9cl/S8zS0TflZBxzuUAfwW24kvQCoBF6LsSLo72u9Es3xklatIimVkS8F/gZ865wsBtzjeUWcOZm4mZnQXsds4tCnUsUkcUMAp4yDk3EijmQFcOoO9Kc/O6xc7Fl0R3ARIJQguMHLtw+m4oUTt6OUC3gPWuXpk0EzOLxpekPeuce8Ur3lXbTeP93O2V6/MKvonAOWa2Gd+tAFPx3RuV6nXvQN333f+ZeNvbAfuaM+A2IhvIds7N89Zfxpe46bsSOt8CNjnn9jjnKoFX8H1/9F0JD0f73WiW74wStaO3AOjrjdKJwXcj6BshjqnN8O7PeAxY5Zy7J2DTG0DtiJsZwOsB5T/wRu2MBwoCmralCTjnbnbOdXXO9cT3ffjEOfc9YCZwgVft4M+k9rO6wKsfFv9zbU2cczuBbWbW3yuaBqxE35VQ2gqMN7ME79+y2s9E35XwcLTfjfeBU82svddaeqpX1qQ04e03YGbfxndPTiTwuHPuj6GNqO0wsxOB2cAyDtwPdQu++9ReBLoDW4CLnHO53j+GD+DrXigBrnDOLWz2wNsIM5sC/NI5d5aZ9cbXwpYGfAVc5pwrN7M44Gl89xfmApc45zaGKORWzcxG4BvgEQNsBK7A9x90fVdCxMxuBy7GN4L9K+BH+O5r0nelGZnZc8AUIAPYhW/05msc5XfDzH6I728QwB+dc/9u8liVqImIiIiEJ3V9ioiIiIQpJWoiIiIiYUqJmoiIiEiYUqImIiIiEqaUqImIiIiEKSVqItLqmVm1mS0JeN10hPo/NrMfNMF5N5tZxrEeR0TaLk3PISKtnpntd84lheC8m4Exzrm9zX1uEWkd1KImIm2W1+L1/8xsmZnNN7M+XvltZvZLb/k6M1tpZkvN7HmvLM3MXvPK5prZMK883cw+MLMVZvYvwALOdZl3jiVm9oiZRYbgkkWkhVGiJiJtQfxBXZ8XB2wrcM4NxTfz+H2H2fcmYKRzbhjwY6/sduArr+wW4Cmv/FZgjnNuMPAqvhnOMbOB+Gajn+icGwFUA99rygsUkdYp6shVRERavFIvQTqc5wJ+3nuY7UuBZ83sNXyPmAE4ETgfwDn3ideSlgJMBs7zyt82szyv/jRgNLDA9zQa4jnwwGcRkXopURORts7Vs1zrTHwJ2NnAb8xs6Dc4hwFPOudu/gb7ikgbpq5PEWnrLg74+WXgBjOLALo552YCvwbaAUnAbLyuS+9B9Hudc4XALOC7XvkZQHvvUB8DF5hZB29bmpn1CN4liUhroRY1EWkL4s1sScD6e8652ik62pvZUqAcuPSg/SKBZ8ysHb5Wsfudc/lmdhvwuLdfCTDDq3878JyZrQC+ALYCOOdWmtlvgQ+85K8SuBrY0sTXKSKtjKbnEJE2S9NniEi4U9eniIiISJhSi5qIiIhImFKLmoiIiEiYUqImIiIiEqaUqImIiIiEKSVqIiIiImFKiZqIiIhImFKiJiIiIhKm/j8BKv8fowYowgAAAABJRU5ErkJggg==\n", + "text/plain": [ + "<Figure size 720x360 with 1 Axes>" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "\n", + "# Initialize Q-table\n", + "q_table = np.zeros((train_states.shape[0], len(actions)))\n", + "\n", + "# Hyperparameters\n", + "alpha = 0.1 # Learning rate\n", + "gamma = 0.9 # Discount factor\n", + "epsilon = 0.1 # Exploration factor\n", + "rewards_per_episod =[]\n", + "\n", + "\n", + "# Initialize rewards_per_episode list\n", + "rewards_per_episode = []\n", + "\n", + "# Training loop for Q-learning\n", + "for episode in range(1000):\n", + " total_reward = 0\n", + " for state_index, state in enumerate(train_states):\n", + " if np.random.uniform(0, 1) < epsilon:\n", + " action = np.random.choice(actions)\n", + " else:\n", + " action = np.argmax(q_table[state_index])\n", + "\n", + " # Reward is whether the action matches the actual deposit status\n", + " reward = 1 if action == train_target.iloc[state_index] else -1\n", + " total_reward += reward\n", + "\n", + " # Update Q-table\n", + " old_value = q_table[state_index, action]\n", + " next_max = np.max(q_table[state_index])\n", + " new_value = (1 - alpha) * old_value + alpha * (reward + gamma * next_max)\n", + " q_table[state_index, action] = new_value\n", + " \n", + " # Append total reward for this episode\n", + " rewards_per_episode.append(total_reward)\n", + "\n", + "# Test the learned Q-table\n", + "predictions = []\n", + "for state in test_states:\n", + " state_index = np.where(np.all(train_states == state, axis=1))[0]\n", + " if state_index.size > 0:\n", + " action = np.argmax(q_table[state_index[0]])\n", + " else:\n", + " action = np.random.choice(actions) # Random action if state not in training\n", + " predictions.append(action)\n", + "\n", + "# Calculate accuracy\n", + "accuracy_rl = round(accuracy_score(test_target, predictions) * 100, 2)\n", + "print(\"Accuracy of Q-learning policy:\", accuracy_rl)\n", + "\n", + "# Print confusion matrix and classification report for Q-learning\n", + "print(\"Confusion Matrix for Q-learning:\")\n", + "print(confusion_matrix(test_target, predictions))\n", + "print(\"Classification Report for Q-learning:\")\n", + "print(classification_report(test_target, predictions))\n", + "\n", + "# Plotting the rewards\n", + "plt.figure(figsize=(10, 5))\n", + "plt.plot(rewards_per_episode, label='Rewards per Episode')\n", + "plt.xlabel('Episode')\n", + "plt.ylabel('Total Reward')\n", + "plt.title('Rewards per Episode Over Training')\n", + "plt.legend()\n", + "plt.show()\n", + "\n", + "# Scale the continuous features\n", + "scaler = StandardScaler()\n", + "train_states = scaler.fit_transform(train_states)\n", + "test_states = scaler.transform(test_states)\n", + "\n", + "# Initialize Q-tables for Double Q-learning\n", + "q_table_1 = np.zeros((len(train_states), len(actions)))\n", + "q_table_2 = np.zeros((len(train_states), len(actions)))\n", + "\n", + "# Hyperparameters\n", + "alpha = 0.1\n", + "gamma = 0.99\n", + "epsilon = 1.0\n", + "epsilon_min = 0.01\n", + "epsilon_decay = 0.995\n", + "num_episodes = 1000\n", + "rewards_per_episode = []\n", + "\n", + "# Training loop for Double Q-learning\n", + "for episode in range(num_episodes):\n", + " total_reward = 0\n", + " for state_index, state in enumerate(train_states):\n", + " if np.random.rand() < epsilon:\n", + " action = np.random.choice(actions)\n", + " else:\n", + " action = np.argmax(q_table_1[state_index] + q_table_2[state_index])\n", + "\n", + " next_state_index = np.random.randint(0, len(train_states))\n", + " next_state = train_states[next_state_index]\n", + " reward = 1 if action == train_target.iloc[state_index] else -1\n", + " total_reward += reward\n", + "\n", + " if np.random.rand() < 0.5:\n", + " best_next_action = np.argmax(q_table_1[next_state_index])\n", + " q_table_1[state_index, action] = (1 - alpha) * q_table_1[state_index, action] + alpha * (reward + gamma * q_table_2[next_state_index, best_next_action])\n", + " else:\n", + " best_next_action = np.argmax(q_table_2[next_state_index])\n", + " q_table_2[state_index, action] = (1 - alpha) * q_table_2[state_index, action] + alpha * (reward + gamma * q_table_1[next_state_index, best_next_action])\n", + " \n", + " rewards_per_episode.append(total_reward)\n", + " epsilon = max(epsilon_min, epsilon * epsilon_decay)\n", + "\n", + "# Testing the learned policy\n", + "predictions = []\n", + "for state in test_states:\n", + " state_index = np.where(np.all(train_states == state, axis=1))[0]\n", + " if state_index.size > 0:\n", + " action = np.argmax(q_table_1[state_index[0]] + q_table_2[state_index[0]])\n", + " else:\n", + " action = np.random.choice(actions) # Random action if state not in training\n", + " predictions.append(action)\n", + "\n", + "accuracy_double_q = round(accuracy_score(test_target, predictions) * 100, 2)\n", + "print(\"Accuracy of Double Q-learning policy:\", accuracy_double_q)\n", + "\n", + "# Print confusion matrix and classification report for Double Q-learning\n", + "print(\"Confusion Matrix for Double Q-learning:\")\n", + "print(confusion_matrix(test_target, predictions))\n", + "print(\"Classification Report for Double Q-learning:\")\n", + "print(classification_report(test_target, predictions))\n", + "\n", + "# Plotting the rewards\n", + "plt.figure(figsize=(10, 5))\n", + "plt.plot(rewards_per_episode, label='Rewards per Episode')\n", + "plt.xlabel('Episode')\n", + "plt.ylabel('Total Reward')\n", + "plt.title('Rewards per Episode Over Training')\n", + "plt.legend()\n", + "plt.show()\n" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.5" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +}