From cff47bc80389969c3ab5833342150501da9f8bfe Mon Sep 17 00:00:00 2001 From: Fazeeia Mohammed <60365101+mindy001@users.noreply.github.com> Date: Sun, 8 Dec 2024 09:10:41 -0800 Subject: [PATCH] Delete .ipynb_checkpoints directory --- .../02_clean_data-checkpoint.py | 181 -- .../03_explory_analysis-checkpoint.py | 73 - .ipynb_checkpoints/README-checkpoint.md | 121 -- .../bank_marketing_analysis-checkpoint.ipynb | 1696 ----------------- .../conda-linux-64-checkpoint.lock | 227 --- .ipynb_checkpoints/download-checkpoint.py | 51 - 6 files changed, 2349 deletions(-) delete mode 100644 .ipynb_checkpoints/02_clean_data-checkpoint.py delete mode 100644 .ipynb_checkpoints/03_explory_analysis-checkpoint.py delete mode 100644 .ipynb_checkpoints/README-checkpoint.md delete mode 100644 .ipynb_checkpoints/bank_marketing_analysis-checkpoint.ipynb delete mode 100644 .ipynb_checkpoints/conda-linux-64-checkpoint.lock delete mode 100644 .ipynb_checkpoints/download-checkpoint.py diff --git a/.ipynb_checkpoints/02_clean_data-checkpoint.py b/.ipynb_checkpoints/02_clean_data-checkpoint.py deleted file mode 100644 index 36ce9de..0000000 --- a/.ipynb_checkpoints/02_clean_data-checkpoint.py +++ /dev/null @@ -1,181 +0,0 @@ -import os -import pandas as pd -import click -import pandera as pa -from pandera import Column, DataFrameSchema -import matplotlib.pyplot as plt - -@click.command() -@click.option('--input_path', type=str, required=True, help="Path to the input CSV file.") -@click.option('--output_path', type=str, required=True, help="Path to save the cleaned/transformed CSV file.") -def preprocess_data(input_path, output_path): - """ - Reads data from the specified input path, validates it, and performs preprocessing. - """ - try: - # Step 1: Load the data with correct delimiter - if not os.path.isfile(input_path): - raise FileNotFoundError(f"The input file does not exist at: {input_path}") - print(f"Reading data from: {input_path}") - bank_data = pd.read_csv(input_path, sep=";") # Use the correct delimiter - - # Step 2: Clean and fix column names - print("Current column names:", bank_data.columns.tolist()) - bank_data.columns = bank_data.columns.str.strip().str.replace('"', "") - expected_columns = ['age', 'job', 'marital', 'education', 'default', 'housing', 'loan', - 'contact', 'month', 'day_of_week', 'duration', 'campaign', 'pdays', - 'previous', 'poutcome', 'emp.var.rate', 'cons.price.idx', - 'cons.conf.idx', 'euribor3m', 'nr.employed', 'y'] - if set(expected_columns).difference(bank_data.columns): - raise ValueError(f"Incorrect column names. Expected columns: {expected_columns}") - - # Step 3: Remove duplicates - if bank_data.duplicated().any(): - print(f"Found {bank_data.duplicated().sum()} duplicate rows. Removing duplicates.") - bank_data = bank_data.drop_duplicates() - - # Step 4: Validate data - validation_errors = validate_data(bank_data) - if validation_errors: - print("Data validation failed with the following errors:") - for error in validation_errors: - print(f"- {error}") - return # Exit if validation fails - - print("Data validation passed!") - - # Step 5: Calculate correlations with the target - correlations = check_correlations_with_target(bank_data) # Ensure this is called only once - print("\nCorrelations with target variable:\n", correlations) - - # Step 6: Save cleaned data - bank_data.to_csv(output_path, index=False) - print(f"Cleaned data saved to: {output_path}") - - except Exception as e: - print(f"Error during preprocessing: {e}") - - -def validate_data(df): - errors = [] - - # 1. Correct column names - expected_columns = [ - 'age', 'job', 'marital', 'education', 'default', 'housing', 'loan', - 'contact', 'month', 'day_of_week', 'duration', 'campaign', 'pdays', - 'previous', 'poutcome', 'emp.var.rate', 'cons.price.idx', - 'cons.conf.idx', 'euribor3m', 'nr.employed', 'y' - ] - if not set(expected_columns).issubset(df.columns): - errors.append(f"Incorrect column names. Expected columns: {expected_columns}") - - # 2. No empty observations - if df.isnull().all(axis=1).any(): - errors.append("Dataset contains rows with all empty values.") - - # 3. Missingness not beyond expected threshold - threshold = 0.1 # 10% threshold for missing data - missing_ratios = df.isnull().mean() - if (missing_ratios > threshold).any(): - high_missing_cols = missing_ratios[missing_ratios > threshold].index.tolist() - errors.append(f"Columns with missingness beyond {threshold * 100}%: {high_missing_cols}") - - # 4. No duplicate observations - if df.duplicated().any(): - errors.append("Dataset contains duplicate rows.") - - return errors - - -def check_outliers(df): - """Checks for outliers in numeric columns.""" - print("Running outlier validation...") - outlier_schema = DataFrameSchema( - { - "age": Column(pa.Int, pa.Check(lambda x: 17 <= x <= 100, name="age_check")), - "duration": Column(pa.Int, pa.Check(lambda x: x >= 0, name="duration_check")), - "campaign": Column(pa.Int, pa.Check(lambda x: x >= 0, name="campaign_check")), - "pdays": Column(pa.Int, pa.Check(lambda x: x >= -1, name="pdays_check")), - "previous": Column(pa.Int, pa.Check(lambda x: x >= 0, name="previous_check")), - "emp.var.rate": Column(pa.Float, pa.Check(lambda x: -3.5 <= x <= 3, name="emp_var_rate_check")), - "cons.price.idx": Column(pa.Float, pa.Check(lambda x: 92 <= x <= 95, name="cons_price_idx_check")), - "cons.conf.idx": Column(pa.Float, pa.Check(lambda x: -51 <= x <= 50, name="cons_conf_idx_check")), - "euribor3m": Column(pa.Float, pa.Check(lambda x: 0 <= x <= 6, name="euribor3m_check")), - "nr.employed": Column(pa.Float, pa.Check(lambda x: 4900 <= x <= 5500, name="nr_employed_check")), - } - ) - try: - outlier_schema.validate(df) - print("Outlier validation passed!") - except pa.errors.SchemaError as e: - raise ValueError(f"Outlier validation failed:\n{e}") - - -def validate_categories(df): - """Validates categorical column values.""" - print("Validating category levels...") - expected_categories = { - "job": ["admin.", "unknown", "unemployed", "management", "housemaid", "entrepreneur", - "student", "blue-collar", "self-employed", "retired", "technician", "services"], - "marital": ["married", "divorced", "single", "unknown"], - "education": ['basic.4y', 'high.school', 'basic.6y', 'basic.9y', 'professional.course', - 'unknown', 'university.degree', 'illiterate'], - "default": ["yes", "no", "unknown"], - "housing": ["yes", "no", "unknown"], - "loan": ["yes", "no", "unknown"], - "contact": ["unknown", "telephone", "cellular"], - "month": ["jan", "feb", "mar", "apr", "may", "jun", "jul", "aug", "sep", "oct", "nov", "dec"], - "day_of_week": ["mon", "tue", "wed", "thu", "fri"], - "poutcome": ['nonexistent', 'failure', 'success'] - } - - for col, categories in expected_categories.items(): - if not set(df[col].unique()).issubset(categories): - raise ValueError(f"Column '{col}' has unexpected category levels.") - print("Category validation passed!") - - -def validate_target(df): - """Validates the target variable.""" - print("Validating target variable...") - target_schema = pa.DataFrameSchema({ - "y": pa.Column(str, pa.Check.isin(['yes', 'no'], error="Target must be 'yes' or 'no'"), nullable=False) - }) - try: - target_schema.validate(df) - print("Target validation passed!") - except pa.errors.SchemaError as e: - print(f"Target validation failed: {e}") - - -def check_correlations_with_target(df): - """Checks correlations with the target variable.""" - print("Checking correlations with the target variable...") - - # Ensure the target variable is numeric for correlation calculation - encoded_df = df.copy() - for col in encoded_df.select_dtypes(include=['object']).columns: - encoded_df[col] = encoded_df[col].astype('category').cat.codes - - if 'y' not in encoded_df.columns: - raise ValueError("Target variable 'y' is not found in the dataset.") - - # Calculate correlation with the target variable - correlations = encoded_df.corr()["y"].drop("y") # Drop self-correlation - # print("Correlations with target variable:\n", correlations) - - return correlations - -def check_feature_correlations(df): - """Checks feature correlations.""" - print("Checking feature correlations...") - encoded_df = df.copy() - for col in encoded_df.select_dtypes(include=['object']).columns: - encoded_df[col] = encoded_df[col].astype('category').cat.codes - - correlations = encoded_df.corr() - print("Feature correlation matrix:\n", correlations) - - -if __name__ == "__main__": - preprocess_data() diff --git a/.ipynb_checkpoints/03_explory_analysis-checkpoint.py b/.ipynb_checkpoints/03_explory_analysis-checkpoint.py deleted file mode 100644 index 06fac5a..0000000 --- a/.ipynb_checkpoints/03_explory_analysis-checkpoint.py +++ /dev/null @@ -1,73 +0,0 @@ -import os -import pandas as pd -import altair as alt -import click - -@click.command() -@click.option('--cleaned_data_path', type=str, required=True, help="Path to the cleaned data file.") -@click.option('--output_prefix', type=str, required=True, help="Prefix for saving the output visualization files.") -def generate_eda(cleaned_data_path, output_prefix): - """ - Generates exploratory data visualizations using the cleaned data and saves them to files. - """ - try: - # Load the cleaned dataset - if not os.path.isfile(cleaned_data_path): - raise FileNotFoundError(f"The cleaned data file does not exist at: {cleaned_data_path}") - print(f"Reading cleaned data from: {cleaned_data_path}") - bank_data = pd.read_csv(cleaned_data_path) - - # Create output directory if it doesn't exist - output_dir = os.path.dirname(output_prefix) - if output_dir and not os.path.exists(output_dir): - os.makedirs(output_dir) - - # Univariate distributions for numeric variables - print("Generating univariate distributions for numeric variables...") - for col in ['age', 'duration', 'campaign', 'previous']: - chart = alt.Chart(bank_data).mark_bar().encode( - alt.X(col, bin=alt.Bin(maxbins=30)), - alt.Y('count()'), - alt.ColorValue('steelblue') - ).properties(title=f'Distribution of {col}') - chart.save(f"{output_prefix}_{col}_dist.png") - - # Univariate distribution for categorical variables - print("Generating univariate distributions for categorical variables...") - target_chart = alt.Chart(bank_data).mark_bar().encode( - x=alt.X('y:N', title='Target Variable (y)'), - y=alt.Y('count()', title='Count'), - color=alt.Color('y:N', scale=alt.Scale(scheme='category10')) - ).properties(title='Target Variable Distribution') - target_chart.save(f"{output_prefix}_target_dist.png") - - # Pairwise correlations for quantitative variables - print("Generating pairwise correlations for quantitative variables...") - corr = bank_data.select_dtypes(include=['number']).corr() - corr_chart = alt.Chart(corr.reset_index().melt('index')).mark_rect().encode( - x=alt.X('index:N', title='Feature'), - y=alt.Y('variable:N', title='Feature'), - color=alt.Color('value:Q', scale=alt.Scale(scheme='blueorange')), - tooltip=['index', 'variable', 'value'] - ).properties(title='Correlation Heatmap') - corr_chart.save(f"{output_prefix}_correlation.png") - - # Pairwise scatterplots for high-correlation variables - print("Generating pairwise scatterplots for high-correlation variables...") - high_corr_columns = ["age", "duration", "campaign", "previous", "y"] - scatter_data = bank_data[high_corr_columns].sample(n=300, random_state=42) - scatter_chart = alt.Chart(scatter_data).mark_point().encode( - x=alt.X('age', title='Age'), - y=alt.Y('duration', title='Duration'), - color=alt.Color('y:N', scale=alt.Scale(scheme='category10')) - ).properties(title='Scatterplot of Age vs Duration') - scatter_chart.save(f"{output_prefix}_scatterplot.png") - - print("EDA visualizations generated and saved successfully!") - - except Exception as e: - print(f"Error during EDA visualization generation: {e}") - - -if __name__ == "__main__": - generate_eda() diff --git a/.ipynb_checkpoints/README-checkpoint.md b/.ipynb_checkpoints/README-checkpoint.md deleted file mode 100644 index 44c550c..0000000 --- a/.ipynb_checkpoints/README-checkpoint.md +++ /dev/null @@ -1,121 +0,0 @@ -# Bank Marketing Campaign Prediction - -**Authors**: Hala Arar, Fazeeia Mohammad, Rong Wan - -## Project Summary - -This project aims to enhance bank marketing campaigns by using machine learning to predict whether a customer will subscribe to a term deposit based on demographic and campaign-related data. The goal is to develop a model that can more effectively target potential customers, improving resource allocation and reducing marketing costs by excluding unlikely subscribers. - -The project explores several machine learning models, including Logistic Regression and Decision Trees. These models are trained on customer data, with preprocessing techniques like feature scaling and one-hot encoding applied to prepare the data for analysis. The outcome of this work demonstrates how banks can leverage machine learning to implement more effective, data-driven marketing strategies, which can lead to better customer acquisition and optimized campaign performance. - -The Logistic Regression model achieved an accuracy of 88.5%, with a focus on minimizing false positives, resulting in a precision of 0.70 and recall of 0.20. Despite its high precision, the model's low recall indicates that it misses a significant portion of actual subscribers. The Decision Tree model, with an accuracy of 89.7%, demonstrated better recall (0.23) but at the cost of increased false positives (126). Both models highlight the class imbalance in the dataset, where non-subscribers are far more prevalent than subscribers. The Logistic Regression model is more suitable when minimizing false positives is prioritized, whereas the Decision Tree model is more effective in identifying potential subscribers but may require further regularization to reduce overfitting. - -Strategic recommendations for targeted marketing, personalized offers, and campaign timing are proposed to optimize resource allocation and improve conversion rates. Future model iterations should focus on improving both precision and recall to enhance marketing efforts and increase return on investment. - -## Report -The final report can be found [here](https://github.com/mindy001/BankMarketingPreditions-/blob/main/reports/bank_marketing_analysis.pdf). - -## How to Run the Analysis - -### Option 1: Run Using Docker - -1. **Install Docker** - -Download and install Docker Desktop for your operating system and ensure it is running. - -2. **Clone the repository** - -Open your terminal and run the following command to clone the project repository to your local machine: - -git clone https://github.com/mindy001/BankMarketingPreditions-.git - -Navigate to the project directory - -cd BankMarketingPreditions- - - -3. **Pull the Docker Image** - -Run the following command in your terminal to pull the project’s Docker image: - -docker pull fazeeia/dsci522-dockerfile-bank:latest - -4. **Run the Docker Container** - -Run the following command in your terminal to start the Docker container and mount your local directory: - -docker run -p 8888:8888 -it -v /$(pwd):/home/jovyan/work fazeeia/dsci522-d - --p 8888:8888: This maps port 8888 inside the container to port 8888 on your local machine (where JupyterLab will be running). --v $(pwd):/home/jovyan/work: This mounts your current working directory to the container’s working directory, allowing you to access your project files inside the container. - -5. **Access JupyterLab** - -You will see a URL in the terminal. Open the link in your browser to access the JupyterLab environment. - - -### Option 2: Run Locally - -1. **Clone the repository** - -git clone https://github.com/mindy001/Group37DSCI522.git - -2. **Set up the environment** - -conda env create -f env/environment.yml -conda activate bankenv - -3. **Run the Analysis** - -After activating the environment, you can run the analysis script or Jupyter notebook called bank_marketing_analysis.ipynb - -4. **Open the Report** - -The final report is available as a PDF. You can view the completed analysis by opening the bank_marketing_analysis.pdf file. -## Running Project scripts -1. Change your directory to the current project directory using the cd command from bash. -2. Scripts are run using the click command in the root of the project. More details about the scripts can be found in the scr directory. -3. These are command lines to run the python files: - python 01_download.py --directory data/bankmarketing/bank-additional/bank-additional/ --filename bank-additional-full.csv - python 02_clean_data.py --input_path data/bankmarketing/bank-additional/bank-additional/bank-additional-full.csv --output_path data/cleaned_bank_data.csv - python 03_explory_analysis.py --cleaned_data_path data/cleaned_bank_data.csv --output_prefix results/eda - python 04_model_LR.py --input_path ./cleaned_data.csv --model_output_path ./model/logistic_regression_model.pkl --confusion_matrix_output .results/eda/confusion_matrixLR.png - python 04_model_DT.py --input_path ./cleaned_data.csv --model_output_path ./model/decision_tree_model.pkl --confusion_matrix_output .results/eda/confusion_matrixDT.png - - - -## Dependencies - -Docker is a container solution used to manage the software dependencies for this project. The Docker image used for this project is based on the quay.io/jupyter/minimal-notebook:notebook-7.0.6 image. Additional dependencies are specified in the Dockerfile. - -To run the analysis and work with the code, you will need to install the following Python packages. These are automatically included in the environment.yml file, but here is the full list for reference: - -altair -numpy -pandas -scikit-learn (includes tools like train_test_split, GridSearchCV, StandardScaler, OneHotEncoder, KNeighborsClassifier, LogisticRegression, DecisionTreeClassifier, etc.) -matplotlib -seaborn -ucimlrepo -altair_ally -click - -These dependencies are necessary for data processing, model building, evaluation, and visualization. - - -## License - -This project is licensed under CC0 1.0 Universal (Creative Commons Public Domain Dedication). By applying this license, the creator voluntarily waives all copyright and related rights, allowing anyone to use, modify, distribute, or build upon the work for any purpose, including commercial purposes, without the need for permission or attribution. - -## References - -Meshref, H. (2020). Predicting loan approval of bank direct marketing data using ensemble machine learning algorithms. International Journal of Circuits, Systems and Signal Processing, 14, 117. https://doi.org/10.46300/9106.2020.14.117 - -Moro, S., Rita, P., & Cortez, P. (2014). Bank Marketing [Dataset]. UCI Machine Learning Repository. https://doi.org/10.24432/C5K306 - -Wang, D. (2020). Research on bank marketing behavior based on machine learning. AIAM2020: Proceedings of the 2nd International Conference on Artificial Intelligence and Advanced Manufacture, 150–154. https://doi.org/10.1145/3421766.3421800 - -Xie, C., Zhang, J.-L., Zhu, Y., Xiong, B., & Wang, G.-J. (2023). How to improve the success of bank telemarketing? Prediction and interpretability analysis based on machine learning. Computers & Industrial Engineering, 175, 108874. https://doi.org/10.1016/j.cie.2022.108874 - -Zaki, A. M., Khodadadi, N., Lim, W. H., & Towfek, S. K. (2024). Predictive analytics and machine learning in direct marketing for anticipating bank term deposit subscriptions. American Journal of Business and Operations Research, 11(1), 79-88. https://doi.org/10.54216/AJBOR.110110 - diff --git a/.ipynb_checkpoints/bank_marketing_analysis-checkpoint.ipynb b/.ipynb_checkpoints/bank_marketing_analysis-checkpoint.ipynb deleted file mode 100644 index 8388adb..0000000 --- a/.ipynb_checkpoints/bank_marketing_analysis-checkpoint.ipynb +++ /dev/null @@ -1,1696 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "id": "c01082bd-6e32-447a-85da-de406315b622", - "metadata": {}, - "source": [ - "# Bank Marketing Analysis" - ] - }, - { - "cell_type": "markdown", - "id": "3bceecc3-6f6e-4134-a944-461302725bda", - "metadata": {}, - "source": [ - "by Rong Wan, Hala Arar & Fazeeia Mohammed 2024/11/21" - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "id": "01648fe3-1355-4e30-8a6c-b20ba1ff0158", - "metadata": {}, - "outputs": [], - "source": [ - "import altair as alt\n", - "import numpy as np\n", - "import pandas as pd\n", - "from sklearn import set_config\n", - "from sklearn.model_selection import train_test_split, GridSearchCV\n", - "from sklearn.preprocessing import StandardScaler, OneHotEncoder\n", - "from sklearn.compose import make_column_transformer, make_column_selector\n", - "from sklearn.neighbors import KNeighborsClassifier\n", - "from sklearn.pipeline import make_pipeline, Pipeline\n", - "from sklearn.linear_model import LogisticRegression\n", - "from sklearn.tree import DecisionTreeClassifier, plot_tree\n", - "from sklearn.metrics import accuracy_score, confusion_matrix, precision_score, recall_score, f1_score\n", - "import matplotlib.pyplot as plt\n", - "import seaborn as sns\n", - "#from ucimlrepo import fetch_ucirepo\n", - "import altair_ally as aly\n", - "import pandera as pa\n", - "from pandera import Column, DataFrameSchema\n", - "from scipy.stats import pointbiserialr, chi2_contingency\n", - "from pandera import Column, DataFrameSchema, Check\n", - "from pandera.errors import SchemaErrors" - ] - }, - { - "cell_type": "markdown", - "id": "f3b0970e-3f66-4e8c-9b09-d4afdc1c2b79", - "metadata": {}, - "source": [ - "# Summary" - ] - }, - { - "cell_type": "markdown", - "id": "1afff777-2bad-4cc1-bbad-2f7f1f97d3a3", - "metadata": {}, - "source": [ - "This lab report analyzes bank marketing campaigns with the goal of using machine learning to predict whether a customer will subscribe to a term deposit. The dataset, sourced from the UCI Machine Learning Repository, contains demographic and campaign-related information on customers who were contacted via phone for a Portuguese bank's direct marketing campaign (Moro et al., 2014). The target variable is whether or not the customer subscribed to a term deposit. This study evaluates the performance of Logistic Regression and Decision Tree models in predicting customer subscription to term deposits, using metrics such as accuracy, precision, recall, and F1 score. The Logistic Regression model achieved 88.5% accuracy with high precision (0.70) but low recall (0.20), making it suitable for minimizing false positives. Conversely, the Decision Tree model achieved 89.7% accuracy with improved recall (0.23) but lower precision (0.63), better identifying potential subscribers at the cost of higher false positives. Both models emphasize the majority class (non-subscribers) and highlight challenges in detecting true positives. Strategic recommendations include targeted marketing, personalized offers, and continuous monitoring and adjustment of the models to improve performance. By leveraging these models, banks can enhance marketing strategies, optimize resource allocation, and increase conversion rates." - ] - }, - { - "cell_type": "markdown", - "id": "96dfc8f2-776d-4c9b-a4cd-03e65b44c181", - "metadata": {}, - "source": [ - "# Introduction" - ] - }, - { - "cell_type": "markdown", - "id": "bf2e2a38-7f9c-4da1-90b6-c9a5a683e1cc", - "metadata": {}, - "source": [ - "Bank marketing campaigns are a critical tool for financial institutions to promote their products and services, particularly time deposit subscriptions (Meshref, 2020). However, identifying potential customers who are likely to respond positively to these campaigns can be challenging (Meshref, 2020). Despite advances in targeted marketing strategies, response rates for bank marketing campaigns remain low, and ineffective campaigns can lead to wasted resources and decreased customer satisfaction (Xie et al., 2023).\n", - "\n", - "One notable study in this area is \"Predictive Analytics and Machine Learning in Direct Marketing for Anticipating Bank Term Deposit Subscriptions\" by Zaki et al. (2024). The authors explore how machine learning models, including the SGD Classifier, k-nearest neighbor Classifier, and Random Forest Classifier, can be used to predict bank term deposit subscriptions. The study employs various data exploration and feature engineering techniques to build and evaluate the models, ultimately identifying the Random Forest Classifier as the most effective, achieving an impressive accuracy of 87.5%. This study underscores the potential of machine learning to enhance marketing strategies in the banking sector, providing valuable insights that can help institutions refine their direct marketing approaches and improve customer acquisition.\n", - "\n", - "In recent years, the use of machine learning and data mining techniques in the banking sector has gained significant traction, particularly for customer targeting and marketing optimization. A study by Wang (2020) examines the application of machine learning algorithms, specifically the C5.0 algorithm, to classify bank customers in order to improve marketing strategies. Using the Bank Marketing dataset from the UCI Machine Learning Repository, the study demonstrates how data mining can help identify customer segments, allowing banks to tailor their marketing campaigns more effectively. The classification model results can enhance decision-making processes for banks, ultimately improving marketing efficiency and customer satisfaction. The study highlights the importance of selecting relevant features, handling outliers, and balancing the dataset to ensure more accurate predictions.\n", - "\n", - "This research raises the question of whether a machine learning algorithm can predict whether a customer will subscribe to a term deposit based on customer demographics and campaign-related data. This is an important inquiry because traditional marketing methods often rely on manual segmentation or generalized strategies, which may not capture the nuances of customer behavior. Additionally, by excluding customers who are unlikely to subscribe, banks can reduce campaign costs and improve customer experience. Conversely, accurately identifying potential subscribers allows banks to concentrate efforts on the right audience, improving both efficiency and outcomes. Therefore, if a machine learning algorithm can accurately predict customer subscriptions based on the bank marketing dataset, it could enable more effective, scalable, and data-driven marketing strategies, leading to better resource allocation and enhanced campaign performance." - ] - }, - { - "cell_type": "markdown", - "id": "68eddbef-dc57-415e-9d40-d8ac80bb9908", - "metadata": {}, - "source": [ - "# Methods " - ] - }, - { - "cell_type": "markdown", - "id": "d419c660-4a09-4723-bfe5-33f3ee5d668d", - "metadata": {}, - "source": [ - "### Data" - ] - }, - { - "cell_type": "markdown", - "id": "dab12fd4-bf69-4cb8-a15e-d4dfb353f3ef", - "metadata": {}, - "source": [ - "The dataset used in this project is the Bank Marketing dataset, sourced from the UCI Machine Learning Repository (Moro et al., 2014). It contains information related to direct marketing campaigns (via phone calls) conducted by a Portuguese banking institution to predict if a client will subscribe to a term deposit. The dataset contains 45,211 rows and 17 columns and it includes features such as age, job type, marital status, education, balance, and details about previous marketing campaigns. The target variable in this study is \"y,\" which indicates whether a customer subscribed to a term deposit (binary: \"yes\" or \"no\"). We processed and analyzed this data using Python with libraries such as pandas, scikit-learn, and matplotlib to implement data cleaning, exploratory data analysis, and machine learning models. The data has been pre-processed and contains no missing values." - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "id": "da5630e4", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Unknown counts in each column:\n", - " age 0\n", - "job 330\n", - "marital 80\n", - "education 1731\n", - "default 8597\n", - "housing 990\n", - "loan 990\n", - "contact 0\n", - "month 0\n", - "day_of_week 0\n", - "duration 0\n", - "campaign 0\n", - "pdays 0\n", - "previous 0\n", - "poutcome 0\n", - "emp.var.rate 0\n", - "cons.price.idx 0\n", - "cons.conf.idx 0\n", - "euribor3m 0\n", - "nr.employed 0\n", - "y 0\n", - "dtype: int64\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "#download and extract data from csv\n", - "bank_data = pd.read_csv(\"data/bankmarketing/bank-additional/bank-additional/bank-additional-full.csv\", sep = \";\")\n", - "bank_data\n", - "\n", - "# Check if 'unknown' is still present in any column\n", - "unknown_counts = bank_data.isin(['unknown']).sum()\n", - "print(\"Unknown counts in each column:\\n\", unknown_counts)\n", - "\n", - "# Plot\n", - "plt.figure(figsize=(8,6))\n", - "sns.countplot(data=bank_data, x='education', hue='loan')\n", - "plt.title('Education Level vs Loan Status')\n", - "plt.xticks(rotation=45)\n", - "plt.show()" - ] - }, - { - "cell_type": "markdown", - "id": "9d028e19-43ae-4593-96ee-c9e7582ad90a", - "metadata": {}, - "source": [ - "| Variable Name | Role | Type | Demographic | Description | Units | Missing Values |\n", - "|----------------|--------|------------|-------------------|-------------------------------------------------------------------------------------------------------------------------------------------------------------------|----------|----------------|\n", - "| age | Feature| Integer | | Age | years | no |\n", - "| job | Feature| Categorical| Occupation | Type of job (categorical: 'admin.', 'blue-collar', 'entrepreneur', 'housemaid', 'management', 'retired', 'self-employed', 'services', 'student', 'technician', 'unemployed', 'unknown') | | no |\n", - "| marital | Feature| Categorical| Marital Status | Marital status (categorical: 'divorced', 'married', 'single', 'unknown'; note: 'divorced' means divorced or widowed) | | no |\n", - "| education | Feature| Categorical| Education Level | Education level (categorical: 'basic.4y', 'basic.6y', 'basic.9y', 'high.school', 'illiterate', 'professional.course', 'university.degree', 'unknown') | | no |\n", - "| default | Feature| Binary | | Has credit in default? (binary: 'yes', 'no') | | no |\n", - "| balance | Feature| Integer | | Average yearly balance (numeric) | euros | no |\n", - "| housing | Feature| Binary | | Has housing loan? (binary: 'yes', 'no') | | no |\n", - "| loan | Feature| Binary | | Has personal loan? (binary: 'yes', 'no') | | no |\n", - "| contact | Feature| Categorical| | Contact communication type (categorical: 'cellular', 'telephone') | | yes |\n", - "| day_of_week | Feature| Date | | Last contact day of the week (categorical: 'mon', 'tue', 'wed', 'thu', 'fri') | | no |\n", - "| month | Feature| Date | | Last contact month of the year (categorical: 'jan', 'feb', 'mar', ..., 'nov', 'dec') | | no |\n", - "| duration | Feature| Integer | | Last contact duration, in seconds (numeric). Important note: this attribute highly affects the output target (e.g., if duration=0 then y='no'). It should only be included for benchmark purposes. | seconds | no |\n", - "| campaign | Feature| Integer | | Number of contacts performed during this campaign and for this client (numeric, includes last contact) | | no |\n", - "| pdays | Feature| Integer | | Number of days that passed by after the client was last contacted from a previous campaign (numeric; -1 means client was not previously contacted) | days | yes |\n", - "| previous | Feature| Integer | | Number of contacts performed before this campaign and for this client | | no |\n", - "| poutcome | Feature| Categorical| | Outcome of the previous marketing campaign (categorical: 'failure', 'nonexistent', 'success') | | yes |\n", - "| y | Target | Binary | | Has the client subscribed to a term deposit? (binary: 'yes', 'no') | | no |\n" - ] - }, - { - "cell_type": "markdown", - "id": "7d8af34f-1ea1-42fe-9c2b-cafa1365dbc4", - "metadata": {}, - "source": [ - "# Data Validation Check" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "id": "60c73a4f-0fd0-491b-ae23-dde8c3b292ff", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Data validation failed with the following errors:\n", - "- Dataset contains duplicate rows.\n" - ] - } - ], - "source": [ - "# Define a function for data validation\n", - "data_path = \"data/bankmarketing/bank-additional/bank-additional/bank-additional-full.csv\"\n", - "\n", - "# Define a function for data validation\n", - "def validate_data(df, file_path):\n", - " errors = []\n", - "\n", - " # 1. Correct data file format\n", - " if not file_path.endswith(\".csv\"):\n", - " errors.append(\"Incorrect file format: Expected a .csv file.\")\n", - "\n", - " # 2. Correct column names\n", - " expected_columns = ['age', 'job', 'marital', 'education', 'default', 'housing', 'loan',\n", - " 'contact', 'month', 'day_of_week', 'duration', 'campaign', 'pdays',\n", - " 'previous', 'poutcome', 'emp.var.rate', 'cons.price.idx',\n", - " 'cons.conf.idx', 'euribor3m', 'nr.employed', 'y'] \n", - " if not set(expected_columns).issubset(df.columns):\n", - " errors.append(f\"Incorrect column names. Expected columns: {expected_columns}\")\n", - "\n", - " # 3. No empty observations\n", - " if df.isnull().all(axis=1).any():\n", - " errors.append(\"Dataset contains rows with all empty values.\")\n", - "\n", - " # 4. Missingness not beyond expected threshold\n", - " threshold = 0.1 # 10% threshold for missing data\n", - " missing_ratios = df.isnull().mean()\n", - " if (missing_ratios > threshold).any():\n", - " high_missing_cols = missing_ratios[missing_ratios > threshold].index.tolist()\n", - " errors.append(f\"Columns with missingness beyond {threshold * 100}%: {high_missing_cols}\")\n", - "\n", - " # 5. Correct data types in each column\n", - " expected_dtypes = {\n", - " 'age': 'int64',\n", - " 'job': 'object',\n", - " 'marital': 'object',\n", - " 'education': 'object',\n", - " 'default': 'object',\n", - " 'balance': 'int64',\n", - " 'housing': 'object',\n", - " 'loan': 'object',\n", - " 'contact': 'object',\n", - " 'day': 'int64',\n", - " 'month': 'object',\n", - " 'duration': 'int64',\n", - " 'campaign': 'int64',\n", - " 'pdays': 'int64',\n", - " 'previous': 'int64',\n", - " 'poutcome': 'object',\n", - " 'y': 'object'\n", - " }\n", - " for col, dtype in expected_dtypes.items():\n", - " if col in df.columns and df[col].dtype.name != dtype:\n", - " errors.append(f\"Incorrect data type for column {col}. Expected {dtype}, got {df[col].dtype.name}.\")\n", - "\n", - " # 6. No duplicate observations\n", - " if df.duplicated().any():\n", - " errors.append(\"Dataset contains duplicate rows.\")\n", - "\n", - " return errors\n", - "\n", - "# Run validation\n", - "validation_errors = validate_data(bank_data, data_path)\n", - "\n", - "# Handle validation errors\n", - "if validation_errors:\n", - " print(\"Data validation failed with the following errors:\")\n", - " for error in validation_errors:\n", - " print(f\"- {error}\")\n", - "else:\n", - " print(\"Data validation passed!\")" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "id": "256d5735-0a5e-493a-9a16-3f87f13955a8", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Data passed outlier validation checks.\n" - ] - } - ], - "source": [ - "# No Outliers or Anomalous values: \n", - "\n", - "\n", - "outlier_schema = DataFrameSchema(\n", - " {\n", - " \"age\": Column(pa.Int, pa.Check(lambda x: (x >= 17) & (x <= 100), name=\"age_check\")),\n", - " \"duration\": Column(pa.Int, pa.Check(lambda x: x >= 0, name=\"duration_check\")), # Duration should be non-negative\n", - " \"campaign\": Column(pa.Int, pa.Check(lambda x: x >= 0, name=\"campaign_check\")), # Campaign count should be >= 0\n", - " \"pdays\": Column(pa.Int, pa.Check(lambda x: x >= -1, name=\"pdays_check\")), # -1 indicates no previous contact\n", - " \"previous\": Column(pa.Int, pa.Check(lambda x: x >= 0, name=\"previous_check\")), # Previous contacts >= 0\n", - " \"emp.var.rate\": Column(pa.Float, pa.Check(lambda x: (x >= -3.5) & (x <= 3), name=\"emp_var_rate_check\")), # Range for employment variation\n", - " \"cons.price.idx\": Column(pa.Float, pa.Check(lambda x: (x >= 92) & (x <= 95), name=\"cons_price_idx_check\")), # Reasonable range for consumer price index\n", - " \"cons.conf.idx\": Column(pa.Float, pa.Check(lambda x: (x >= -51) & (x <= 50), name=\"cons_conf_idx_check\")), # Consumer confidence range\n", - " \"euribor3m\": Column(pa.Float, pa.Check(lambda x: (x >= 0) & (x <= 6), name=\"euribor3m_check\")), # EURIBOR rate should be non-negative and below 6\n", - " \"nr.employed\": Column(pa.Float, pa.Check(lambda x: (x >= 4900) & (x <= 5500), name=\"nr_employed_check\")), # Number of employees range\n", - " }\n", - ")\n", - "\n", - "# Validate the dataframe for outliers\n", - "try:\n", - " outlier_schema.validate(bank_data)\n", - " print(\"Data passed outlier validation checks.\")\n", - "except pa.errors.SchemaError as e:\n", - " print(\"Outlier validation failed:\")\n", - " print(e)" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "id": "f06e4124-285b-4697-a6d4-e28dafde6093", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Data passed category level validation checks.\n" - ] - } - ], - "source": [ - "# Correct Category Levels (No String Mismatches or Single Values)\n", - "expected_categories = {\n", - " \"job\": [\"admin.\", \"unknown\", \"unemployed\", \"management\", \"housemaid\", \"entrepreneur\", \n", - " \"student\", \"blue-collar\", \"self-employed\", \"retired\", \"technician\", \"services\"],\n", - " \"marital\": [\"married\", \"divorced\", \"single\", \"unknown\"],\n", - " \"education\": ['basic.4y', 'high.school', 'basic.6y', 'basic.9y', 'professional.course',\n", - " 'unknown', 'university.degree', 'illiterate'],\n", - " \"default\": [\"yes\", \"no\", \"unknown\"],\n", - " \"housing\": [\"yes\", \"no\", \"unknown\"],\n", - " \"loan\": [\"yes\", \"no\", \"unknown\"],\n", - " \"contact\": [\"unknown\", \"telephone\", \"cellular\"],\n", - " \"month\": [\"jan\", \"feb\", \"mar\", \"apr\", \"may\", \"jun\", \"jul\", \"aug\", \"sep\", \"oct\", \"nov\", \"dec\"],\n", - " \"day_of_week\": [\"mon\", \"tue\", \"wed\", \"thu\", \"fri\"],\n", - " \"poutcome\": ['nonexistent', 'failure', 'success']\n", - "}\n", - "\n", - "# Define the schema for category level checks\n", - "category_schema = DataFrameSchema(\n", - " {\n", - " \"job\": Column(pa.String, pa.Check(lambda x: set(x.unique()).issubset(expected_categories[\"job\"]), name=\"job_check\")),\n", - " \"marital\": Column(pa.String, pa.Check(lambda x: set(x.unique()).issubset(expected_categories[\"marital\"]), name=\"marital_check\")),\n", - " \"education\": Column(pa.String, pa.Check(lambda x: set(x.unique()).issubset(expected_categories[\"education\"]), name=\"education_check\")),\n", - " \"default\": Column(pa.String, pa.Check(lambda x: set(x.unique()).issubset(expected_categories[\"default\"]), name=\"default_check\")),\n", - " \"housing\": Column(pa.String, pa.Check(lambda x: set(x.unique()).issubset(expected_categories[\"housing\"]), name=\"housing_check\")),\n", - " \"loan\": Column(pa.String, pa.Check(lambda x: set(x.unique()).issubset(expected_categories[\"loan\"]), name=\"loan_check\")),\n", - " \"contact\": Column(pa.String, pa.Check(lambda x: set(x.unique()).issubset(expected_categories[\"contact\"]), name=\"contact_check\")),\n", - " \"month\": Column(pa.String, pa.Check(lambda x: set(x.unique()).issubset(expected_categories[\"month\"]), name=\"month_check\")),\n", - " \"day_of_week\": Column(pa.String, pa.Check(lambda x: set(x.unique()).issubset(expected_categories[\"day_of_week\"]), name=\"day_of_week_check\")),\n", - " \"poutcome\": Column(pa.String, pa.Check(lambda x: set(x.unique()).issubset(expected_categories[\"poutcome\"]), name=\"poutcome_check\")),\n", - " }\n", - ")\n", - "\n", - "# Validate the dataframe for category level mismatches\n", - "try:\n", - " category_schema.validate(bank_data)\n", - " print(\"Data passed category level validation checks.\")\n", - " \n", - " # Check for columns with only a single unique value\n", - " for col in bank_data.select_dtypes(include=['object']).columns:\n", - " unique_values = bank_data[col].nunique()\n", - " if unique_values == 1:\n", - " print(f\"Warning: Column '{col}' has only one unique value. It may be non-informative.\")\n", - "\n", - "except pa.errors.SchemaError as e:\n", - " print(\"Category level validation failed:\")\n", - " print(e)" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "id": "e51d7284", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Target validation passed.\n" - ] - } - ], - "source": [ - "# Target/Response Variable Follows Expected Distribution \n", - "# Define the schema for validating the target column 'y'\n", - "target_schema = pa.DataFrameSchema({\n", - " \"y\": pa.Column(str, pa.Check.isin(['yes', 'no'], error=\"Target must be 'yes' or 'no'\"), nullable=False)\n", - "})\n", - "\n", - "# Validate the DataFrame\n", - "try:\n", - " validated_target = target_schema.validate(bank_data)\n", - " print(\"Target validation passed.\")\n", - "except pa.errors.SchemaError as e:\n", - " print(\"Target validation failed:\\n\", e.failure_cases)\n" - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "id": "0a784e40", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Distribution of 'y':\n", - "y\n", - "no 36548\n", - "yes 4640\n", - "Name: count, dtype: int64\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "# Check the distribution of the target variable 'y'\n", - "target_column = 'y'\n", - "\n", - "# Calculate the value counts for the target variable\n", - "target_counts = bank_data[target_column].value_counts()\n", - "\n", - "# Print out the distribution\n", - "print(f\"Distribution of '{target_column}':\")\n", - "print(target_counts)\n", - "\n", - "# Plot the distribution for visual inspection\n", - "plt.figure(figsize=(6, 4))\n", - "target_counts.plot(kind='bar', color=['skyblue', 'lightcoral'])\n", - "plt.title(f\"Distribution of '{target_column}'\")\n", - "plt.xlabel(target_column)\n", - "plt.ylabel('Count')\n", - "plt.xticks(rotation=0)\n", - "plt.show()\n", - "\n" - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "id": "5483f607", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Correlations with target variable:\n", - " age 0.030399\n", - "job 0.025122\n", - "marital 0.046203\n", - "education 0.057799\n", - "default -0.099352\n", - "housing 0.011552\n", - "loan -0.004909\n", - "contact -0.144773\n", - "month -0.006065\n", - "day_of_week 0.015967\n", - "duration 0.405274\n", - "campaign -0.066357\n", - "pdays -0.324914\n", - "previous 0.230181\n", - "poutcome 0.129789\n", - "emp.var.rate -0.298334\n", - "cons.price.idx -0.136211\n", - "cons.conf.idx 0.054878\n", - "euribor3m -0.307771\n", - "nr.employed -0.354678\n", - "Name: y, dtype: float64\n" - ] - } - ], - "source": [ - "# No Anomalous Correlations Between Target/Response Variable and Features\n", - "\n", - "def check_correlations_with_target(data):\n", - " # Convert categorical variables to numerical for correlation analysis\n", - " data_encoded = data.copy()\n", - " for column in data_encoded.select_dtypes(include=['object']).columns:\n", - " data_encoded[column] = data_encoded[column].astype('category').cat.codes\n", - " \n", - " correlation_with_target = data_encoded.corr()['y'].drop('y')\n", - " print(\"Correlations with target variable:\\n\", correlation_with_target)\n", - " \n", - " # Check for high correlations (greater than 0.9 or less than -0.9)\n", - " anomalous_correlations = correlation_with_target[abs(correlation_with_target) > 0.9]\n", - " if not anomalous_correlations.empty:\n", - " print(f\"Warning: Anomalous correlations between target and features: {anomalous_correlations}\")\n", - " \n", - "try:\n", - " check_correlations_with_target(bank_data)\n", - "except Exception as e:\n", - " print(\"Error in correlation with target check:\", e)\n" - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "id": "c220559a", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Feature correlation matrix:\n", - " age job marital education default housing \\\n", - "age 1.000000 0.001250 -0.389753 -0.117892 0.164965 -0.001603 \n", - "job 0.001250 1.000000 0.027897 0.134121 -0.028277 0.006962 \n", - "marital -0.389753 0.027897 1.000000 0.109220 -0.079450 0.010467 \n", - "education -0.117892 0.134121 0.109220 1.000000 -0.186859 0.016825 \n", - "default 0.164965 -0.028277 -0.079450 -0.186859 1.000000 -0.015815 \n", - "housing -0.001603 0.006962 0.010467 0.016825 -0.015815 1.000000 \n", - "loan -0.007368 -0.010209 0.005788 0.006384 -0.003782 0.044296 \n", - "contact 0.007021 -0.025132 -0.054501 -0.105726 0.135238 -0.082186 \n", - "month -0.024877 -0.033213 -0.007629 -0.082684 -0.015830 -0.018141 \n", - "day_of_week -0.017572 -0.000844 0.002202 -0.017986 -0.008701 0.003339 \n", - "duration -0.000866 -0.006490 0.010290 -0.015102 -0.011794 -0.007658 \n", - "campaign 0.004594 -0.006923 -0.007240 0.000371 0.032825 -0.011010 \n", - "pdays -0.034369 -0.028468 -0.037942 -0.046626 0.080062 -0.010551 \n", - "previous 0.024365 0.020965 0.038689 0.038831 -0.102416 0.021314 \n", - "poutcome 0.019750 0.011504 0.001912 0.017009 0.023417 -0.011783 \n", - "emp.var.rate -0.000371 -0.008271 -0.084210 -0.043778 0.203263 -0.060196 \n", - "cons.price.idx 0.000857 -0.016017 -0.057477 -0.081607 0.168073 -0.080504 \n", - "cons.conf.idx 0.129372 0.052760 -0.033783 0.078799 0.026522 -0.033845 \n", - "euribor3m 0.010767 -0.007880 -0.091939 -0.036380 0.195336 -0.059277 \n", - "nr.employed -0.017725 -0.019574 -0.086199 -0.041492 0.189845 -0.045862 \n", - "y 0.030399 0.025122 0.046203 0.057799 -0.099352 0.011552 \n", - "\n", - " loan contact month day_of_week ... campaign \\\n", - "age -0.007368 0.007021 -0.024877 -0.017572 ... 0.004594 \n", - "job -0.010209 -0.025132 -0.033213 -0.000844 ... -0.006923 \n", - "marital 0.005788 -0.054501 -0.007629 0.002202 ... -0.007240 \n", - "education 0.006384 -0.105726 -0.082684 -0.017986 ... 0.000371 \n", - "default -0.003782 0.135238 -0.015830 -0.008701 ... 0.032825 \n", - "housing 0.044296 -0.082186 -0.018141 0.003339 ... -0.011010 \n", - "loan 1.000000 -0.008556 -0.005705 -0.009344 ... 0.005166 \n", - "contact -0.008556 1.000000 0.276565 -0.009575 ... 0.077368 \n", - "month -0.005705 0.276565 1.000000 0.027677 ... -0.062059 \n", - "day_of_week -0.009344 -0.009575 0.027677 1.000000 ... -0.038288 \n", - "duration -0.000916 -0.026657 0.003690 0.021950 ... -0.071699 \n", - "campaign 0.005166 0.077368 -0.062059 -0.038288 ... 1.000000 \n", - "pdays 0.000345 0.117970 -0.047891 -0.009531 ... 0.052584 \n", - "previous -0.001327 -0.212848 0.103157 -0.004102 ... -0.079141 \n", - "poutcome -0.001511 0.118744 -0.065012 0.018732 ... 0.032586 \n", - "emp.var.rate 0.001849 0.393584 -0.178782 0.033245 ... 0.150754 \n", - "cons.price.idx -0.002430 0.591474 -0.004239 0.005644 ... 0.127836 \n", - "cons.conf.idx -0.012025 0.251614 0.009652 0.041465 ... -0.013733 \n", - "euribor3m 0.000125 0.399773 -0.117264 0.039043 ... 0.135133 \n", - "nr.employed 0.003903 0.269155 -0.221425 0.028380 ... 0.144095 \n", - "y -0.004909 -0.144773 -0.006065 0.015967 ... -0.066357 \n", - "\n", - " pdays previous poutcome emp.var.rate cons.price.idx \\\n", - "age -0.034369 0.024365 0.019750 -0.000371 0.000857 \n", - "job -0.028468 0.020965 0.011504 -0.008271 -0.016017 \n", - "marital -0.037942 0.038689 0.001912 -0.084210 -0.057477 \n", - "education -0.046626 0.038831 0.017009 -0.043778 -0.081607 \n", - "default 0.080062 -0.102416 0.023417 0.203263 0.168073 \n", - "housing -0.010551 0.021314 -0.011783 -0.060196 -0.080504 \n", - "loan 0.000345 -0.001327 -0.001511 0.001849 -0.002430 \n", - "contact 0.117970 -0.212848 0.118744 0.393584 0.591474 \n", - "month -0.047891 0.103157 -0.065012 -0.178782 -0.004239 \n", - "day_of_week -0.009531 -0.004102 0.018732 0.033245 0.005644 \n", - "duration -0.047577 0.020640 0.033360 -0.027968 0.005312 \n", - "campaign 0.052584 -0.079141 0.032586 0.150754 0.127836 \n", - "pdays 1.000000 -0.587514 -0.475619 0.271004 0.078889 \n", - "previous -0.587514 1.000000 -0.313110 -0.420489 -0.203130 \n", - "poutcome -0.475619 -0.313110 1.000000 0.192972 0.211330 \n", - "emp.var.rate 0.271004 -0.420489 0.192972 1.000000 0.775334 \n", - "cons.price.idx 0.078889 -0.203130 0.211330 0.775334 1.000000 \n", - "cons.conf.idx -0.091342 -0.050936 0.178289 0.196041 0.058986 \n", - "euribor3m 0.296899 -0.454494 0.184144 0.972245 0.688230 \n", - "nr.employed 0.372605 -0.501333 0.119689 0.906970 0.522034 \n", - "y -0.324914 0.230181 0.129789 -0.298334 -0.136211 \n", - "\n", - " cons.conf.idx euribor3m nr.employed y \n", - "age 0.129372 0.010767 -0.017725 0.030399 \n", - "job 0.052760 -0.007880 -0.019574 0.025122 \n", - "marital -0.033783 -0.091939 -0.086199 0.046203 \n", - "education 0.078799 -0.036380 -0.041492 0.057799 \n", - "default 0.026522 0.195336 0.189845 -0.099352 \n", - "housing -0.033845 -0.059277 -0.045862 0.011552 \n", - "loan -0.012025 0.000125 0.003903 -0.004909 \n", - "contact 0.251614 0.399773 0.269155 -0.144773 \n", - "month 0.009652 -0.117264 -0.221425 -0.006065 \n", - "day_of_week 0.041465 0.039043 0.028380 0.015967 \n", - "duration -0.008173 -0.032897 -0.044703 0.405274 \n", - "campaign -0.013733 0.135133 0.144095 -0.066357 \n", - "pdays -0.091342 0.296899 0.372605 -0.324914 \n", - "previous -0.050936 -0.454494 -0.501333 0.230181 \n", - "poutcome 0.178289 0.184144 0.119689 0.129789 \n", - "emp.var.rate 0.196041 0.972245 0.906970 -0.298334 \n", - "cons.price.idx 0.058986 0.688230 0.522034 -0.136211 \n", - "cons.conf.idx 1.000000 0.277686 0.100513 0.054878 \n", - "euribor3m 0.277686 1.000000 0.945154 -0.307771 \n", - "nr.employed 0.100513 0.945154 1.000000 -0.354678 \n", - "y 0.054878 -0.307771 -0.354678 1.000000 \n", - "\n", - "[21 rows x 21 columns]\n", - "Warning: Anomalous correlations between features:\n", - " age job marital education default housing loan contact \\\n", - "age 1.0 NaN NaN NaN NaN NaN NaN NaN \n", - "job NaN 1.0 NaN NaN NaN NaN NaN NaN \n", - "marital NaN NaN 1.0 NaN NaN NaN NaN NaN \n", - "education NaN NaN NaN 1.0 NaN NaN NaN NaN \n", - "default NaN NaN NaN NaN 1.0 NaN NaN NaN \n", - "housing NaN NaN NaN NaN NaN 1.0 NaN NaN \n", - "loan NaN NaN NaN NaN NaN NaN 1.0 NaN \n", - "contact NaN NaN NaN NaN NaN NaN NaN 1.0 \n", - "month NaN NaN NaN NaN NaN NaN NaN NaN \n", - "day_of_week NaN NaN NaN NaN NaN NaN NaN NaN \n", - "duration NaN NaN NaN NaN NaN NaN NaN NaN \n", - "campaign NaN NaN NaN NaN NaN NaN NaN NaN \n", - "pdays NaN NaN NaN NaN NaN NaN NaN NaN \n", - "previous NaN NaN NaN NaN NaN NaN NaN NaN \n", - "poutcome NaN NaN NaN NaN NaN NaN NaN NaN \n", - "emp.var.rate NaN NaN NaN NaN NaN NaN NaN NaN \n", - "cons.price.idx NaN NaN NaN NaN NaN NaN NaN NaN \n", - "cons.conf.idx NaN NaN NaN NaN NaN NaN NaN NaN \n", - "euribor3m NaN NaN NaN NaN NaN NaN NaN NaN \n", - "nr.employed NaN NaN NaN NaN NaN NaN NaN NaN \n", - "y NaN NaN NaN NaN NaN NaN NaN NaN \n", - "\n", - " month day_of_week ... campaign pdays previous poutcome \\\n", - "age NaN NaN ... NaN NaN NaN NaN \n", - "job NaN NaN ... NaN NaN NaN NaN \n", - "marital NaN NaN ... NaN NaN NaN NaN \n", - "education NaN NaN ... NaN NaN NaN NaN \n", - "default NaN NaN ... NaN NaN NaN NaN \n", - "housing NaN NaN ... NaN NaN NaN NaN \n", - "loan NaN NaN ... NaN NaN NaN NaN \n", - "contact NaN NaN ... NaN NaN NaN NaN \n", - "month 1.0 NaN ... NaN NaN NaN NaN \n", - "day_of_week NaN 1.0 ... NaN NaN NaN NaN \n", - "duration NaN NaN ... NaN NaN NaN NaN \n", - "campaign NaN NaN ... 1.0 NaN NaN NaN \n", - "pdays NaN NaN ... NaN 1.0 NaN NaN \n", - "previous NaN NaN ... NaN NaN 1.0 NaN \n", - "poutcome NaN NaN ... NaN NaN NaN 1.0 \n", - "emp.var.rate NaN NaN ... NaN NaN NaN NaN \n", - "cons.price.idx NaN NaN ... NaN NaN NaN NaN \n", - "cons.conf.idx NaN NaN ... NaN NaN NaN NaN \n", - "euribor3m NaN NaN ... NaN NaN NaN NaN \n", - "nr.employed NaN NaN ... NaN NaN NaN NaN \n", - "y NaN NaN ... NaN NaN NaN NaN \n", - "\n", - " emp.var.rate cons.price.idx cons.conf.idx euribor3m \\\n", - "age NaN NaN NaN NaN \n", - "job NaN NaN NaN NaN \n", - "marital NaN NaN NaN NaN \n", - "education NaN NaN NaN NaN \n", - "default NaN NaN NaN NaN \n", - "housing NaN NaN NaN NaN \n", - "loan NaN NaN NaN NaN \n", - "contact NaN NaN NaN NaN \n", - "month NaN NaN NaN NaN \n", - "day_of_week NaN NaN NaN NaN \n", - "duration NaN NaN NaN NaN \n", - "campaign NaN NaN NaN NaN \n", - "pdays NaN NaN NaN NaN \n", - "previous NaN NaN NaN NaN \n", - "poutcome NaN NaN NaN NaN \n", - "emp.var.rate 1.000000 NaN NaN 0.972245 \n", - "cons.price.idx NaN 1.0 NaN NaN \n", - "cons.conf.idx NaN NaN 1.0 NaN \n", - "euribor3m 0.972245 NaN NaN 1.000000 \n", - "nr.employed 0.906970 NaN NaN 0.945154 \n", - "y NaN NaN NaN NaN \n", - "\n", - " nr.employed y \n", - "age NaN NaN \n", - "job NaN NaN \n", - "marital NaN NaN \n", - "education NaN NaN \n", - "default NaN NaN \n", - "housing NaN NaN \n", - "loan NaN NaN \n", - "contact NaN NaN \n", - "month NaN NaN \n", - "day_of_week NaN NaN \n", - "duration NaN NaN \n", - "campaign NaN NaN \n", - "pdays NaN NaN \n", - "previous NaN NaN \n", - "poutcome NaN NaN \n", - "emp.var.rate 0.906970 NaN \n", - "cons.price.idx NaN NaN \n", - "cons.conf.idx NaN NaN \n", - "euribor3m 0.945154 NaN \n", - "nr.employed 1.000000 NaN \n", - "y NaN 1.0 \n", - "\n", - "[21 rows x 21 columns]\n" - ] - } - ], - "source": [ - "# No Anomalous Correlations Between Features\n", - "\n", - "def check_feature_correlations(data):\n", - " # Convert categorical variables to numerical for correlation analysis\n", - " data_encoded = data.copy()\n", - " for column in data_encoded.select_dtypes(include=['object']).columns:\n", - " data_encoded[column] = data_encoded[column].astype('category').cat.codes\n", - " \n", - " # Calculate correlation matrix\n", - " feature_correlations = data_encoded.corr()\n", - " print(\"Feature correlation matrix:\\n\", feature_correlations)\n", - " \n", - " # Find highly correlated features (greater than 0.9 or less than -0.9)\n", - " high_correlation = feature_correlations[abs(feature_correlations) > 0.9]\n", - " high_correlation = high_correlation[(high_correlation != 1).any(axis=1)] # Remove self-correlations\n", - " \n", - " if not high_correlation.empty:\n", - " print(f\"Warning: Anomalous correlations between features:\\n{high_correlation}\")\n", - " \n", - "try:\n", - " check_feature_correlations(bank_data)\n", - "except Exception as e:\n", - " print(\"Error in feature correlation check:\", e)\n" - ] - }, - { - "cell_type": "markdown", - "id": "eda4d9b1-ed14-4180-a050-730518e416e3", - "metadata": {}, - "source": [ - "### Analysis" - ] - }, - { - "cell_type": "markdown", - "id": "97a4361b-1edf-4643-97cc-65df9c72310b", - "metadata": {}, - "source": [ - "The analysis began with loading and preprocessing the dataset, addressing missing values, encoding categorical features, and scaling numeric variables to ensure consistency across features. The dataset was then split into training and testing sets, with 20% allocated for testing to evaluate model performance. A logistic regression model was chosen for binary classification, implemented through a Pipeline to streamline preprocessing, encoding, and model fitting. To optimize model accuracy, GridSearchCV was used for hyperparameter tuning, and cross-validation was employed to assess the model's robustness. After training the model, its performance was evaluated using various metrics such as accuracy, precision, recall, and F1-score, with confusion matrices and heatmaps created using Seaborn for better visualization. These tools provided insights into the model's ability to differentiate between classes. " - ] - }, - { - "cell_type": "markdown", - "id": "b530cdfa-c44b-4cb6-9f9e-2c71d308a073", - "metadata": {}, - "source": [ - "## Results" - ] - }, - { - "cell_type": "markdown", - "id": "52475fad-2171-43f5-af3c-3c23e38d7483", - "metadata": {}, - "source": [ - "To evaluate the utility of each predictor in predicting the response variable (y) for the bank marketing dataset, we visualized the distributions of each predictor in the training dataset, coloring them by the class (yes: orange and no: blue). These visualizations include univariate distributions, pairwise correlations, and scatterplots, as seen in the attached figures. In analyzing these plots, we observe significant differences in the distribution centers and spreads of predictors like duration and campaign between the two classes. However, some variables, such as age and balance, show overlapping distributions with less apparent class separation. Furthermore, categorical predictors, such as job and month, exhibit class imbalance but may still hold valuable predictive information. Based on these insights, predictors demonstrating clear separability and meaningful patterns are prioritized for inclusion in the predictive model, while those showing little to no differentiation may be considered for exclusion." - ] - }, - { - "cell_type": "code", - "execution_count": 10, - "id": "ad586055-3e5f-4929-afe6-4baae65f8098", - "metadata": {}, - "outputs": [], - "source": [ - "## visualization" - ] - }, - { - "cell_type": "code", - "execution_count": 11, - "id": "e8b1da9d-2571-444b-81aa-59dd71ef7ce5", - "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "\n", - "\n", - "
\n", - "" - ], - "text/plain": [ - "alt.ConcatChart(...)" - ] - }, - "execution_count": 11, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "# Assuming the Bank Marketing dataset is loaded into a DataFrame called `bank_data`\n", - "aly.alt.data_transformers.enable('vegafusion')\n", - "\n", - "# Look at the univariate distributions for quantitative variables\n", - "aly.dist(bank_data, color='y')\n" - ] - }, - { - "cell_type": "code", - "execution_count": 12, - "id": "2b20734c-3687-45d0-b7a1-9a9f94672e9e", - "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "\n", - "\n", - "
\n", - "" - ], - "text/plain": [ - "alt.ConcatChart(...)" - ] - }, - "execution_count": 12, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "# Look at the univariate distributions (counts) for categorical variables\n", - "# Changing 'target' to an object dtype just for the data passed to the chart\n", - "aly.dist(\n", - " bank_data.assign(target=lambda bank_data: bank_data['y'].astype(object)),\n", - " dtype='object',\n", - " color='y'\n", - ")" - ] - }, - { - "cell_type": "code", - "execution_count": 13, - "id": "5258509e-fcc1-4748-852f-923a1064ce54", - "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "\n", - "\n", - "
\n", - "" - ], - "text/plain": [ - "alt.ConcatChart(...)" - ] - }, - "execution_count": 13, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "# Visualize pairwise correlations for quantitative variables\n", - "aly.corr(bank_data)" - ] - }, - { - "cell_type": "code", - "execution_count": 14, - "id": "b51e20ac-bd59-430c-ba4d-bdb624affc20", - "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "\n", - "\n", - "
\n", - "" - ], - "text/plain": [ - "alt.VConcatChart(...)" - ] - }, - "execution_count": 14, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "# Visualize pairwise scatterplots for quantitative variables with high correlations\n", - "# Identify columns with at least one high correlation\n", - "high_corr_columns = [\n", - " \"age\",\n", - " \"duration\",\n", - " \"campaign\",\n", - " \"previous\",\n", - " \"y\", # Always include the target as well\n", - "]\n", - "\n", - "# Sampling the DataFrame to not saturate the charts\n", - "aly.pair(bank_data[high_corr_columns].sample(300), color='y')" - ] - }, - { - "cell_type": "markdown", - "id": "e5ead238-5d12-468e-a8a8-063da1c54593", - "metadata": {}, - "source": [ - "## Model Creation\n", - "### Initially without Hyperparameter optimization using grid search" - ] - }, - { - "cell_type": "code", - "execution_count": 15, - "id": "e6669b07-cc56-482e-8f6c-72458746d83a", - "metadata": { - "scrolled": true - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Accuracy: 0.8975479485311969\n", - "Confusion Matrix:\n", - " [[7198 105]\n", - " [ 739 196]]\n", - "Logistic Regression Evaluation:\n", - "Accuracy: 0.90\n", - "Precision: 0.65\n", - "Recall: 0.21\n", - "F1 Score: 0.32\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "# Set a seed for reproducibility\n", - "np.random.seed(42)\n", - "\n", - "# Assuming bank_data is already loaded\n", - "unknown_columns = bank_data.columns[bank_data.isin(['unknown']).any()]\n", - "\n", - "# Clean the data by replacing 'unknown' values with a placeholder (e.g., 'other')\n", - "cleaned_data = bank_data.apply(lambda col: col.replace('unknown', 'other') if col.dtypes == 'object' else col)\n", - "\n", - "# Define feature subsets\n", - "numeric_feats = ['age', 'emp.var.rate', 'cons.price.idx', 'cons.conf.idx', 'euribor3m', 'nr.employed', 'campaign']\n", - "categorical_feats = ['job', 'education', 'default', 'housing', 'loan', 'contact', 'poutcome']\n", - "drop_feats = ['duration', 'month', 'day_of_week', 'pdays', 'marital', 'previous']\n", - "\n", - "# Separate features and target variable\n", - "X = cleaned_data.drop(columns=drop_feats + ['y']) # Features excluding target 'y' and drop_feats\n", - "y = cleaned_data['y'] # Target variable\n", - "\n", - "# Create the column transformer to apply preprocessing\n", - "ct = make_column_transformer(\n", - " (StandardScaler(), numeric_feats), # Standard scaling for numeric features\n", - " (OneHotEncoder(drop=\"if_binary\", sparse_output=False), categorical_feats) # One-hot encoding for categorical features\n", - ")\n", - "\n", - "# Create a pipeline with preprocessing and logistic regression model\n", - "pipeline = Pipeline(steps=[\n", - " ('preprocessor', ct),\n", - " ('classifier', LogisticRegression(solver='liblinear')) # Using 'liblinear' solver for small datasets\n", - "])\n", - "\n", - "# Split the data into training and testing sets\n", - "X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)\n", - "\n", - "# Train the model\n", - "pipeline.fit(X_train, y_train)\n", - "\n", - "# Make predictions\n", - "y_pred = pipeline.predict(X_test)\n", - "\n", - "# Evaluate the model\n", - "accuracy = accuracy_score(y_test, y_pred)\n", - "conf_matrix = confusion_matrix(y_test, y_pred)\n", - "\n", - "# Print evaluation metrics\n", - "print(\"Accuracy:\", accuracy)\n", - "print(\"Confusion Matrix:\\n\", conf_matrix)\n", - "\n", - "# Additional evaluation metrics\n", - "precision = precision_score(y_test, y_pred, pos_label='yes') # Specify pos_label\n", - "recall = recall_score(y_test, y_pred, pos_label='yes')\n", - "f1 = f1_score(y_test, y_pred, pos_label='yes')\n", - "\n", - "# Print additional metrics\n", - "print(\"Logistic Regression Evaluation:\")\n", - "print(f\"Accuracy: {accuracy:.2f}\")\n", - "print(f\"Precision: {precision:.2f}\")\n", - "print(f\"Recall: {recall:.2f}\")\n", - "print(f\"F1 Score: {f1:.2f}\")\n", - "\n", - "# Plot confusion matrix heatmap\n", - "plt.figure(figsize=(6, 5))\n", - "sns.heatmap(conf_matrix, annot=True, fmt=\"d\", cmap=\"Blues\", xticklabels=['No', 'Yes'], yticklabels=['No', 'Yes'])\n", - "plt.title('Confusion Matrix Heatmap')\n", - "plt.xlabel('Predicted')\n", - "plt.ylabel('Actual')\n", - "plt.show()\n", - "\n" - ] - }, - { - "cell_type": "code", - "execution_count": 16, - "id": "51724900-786f-401e-ad2e-ca135f9e5e91", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Best hyperparameters found: {'classifier__C': 0.1, 'classifier__max_iter': 300, 'classifier__penalty': 'l1', 'classifier__solver': 'liblinear'}\n", - "Accuracy: 0.8852082650049197\n", - "Confusion Matrix:\n", - " [[5236 68]\n", - " [ 632 162]]\n", - "Logistic Regression Evaluation:\n", - "Accuracy: 0.89\n", - "Precision: 0.70\n", - "Recall: 0.20\n", - "F1 Score: 0.32\n" - ] - }, - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAgsAAAHUCAYAAAC032upAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjkuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8hTgPZAAAACXBIWXMAAA9hAAAPYQGoP6dpAABKHklEQVR4nO3de1yO9/8H8Nfd6Vapm6ISOYdSI4clRqacU4Y5ZDnlbIiMZV9qs5XD5lRzmFMYa74OfcesZQ5tJh1MG2lm5NBXKSRKkrp+f/i6fruV2xV37nS9nt/H9Xjoc73v6/pcd+3bu/f7+ly3QhAEAURERETPoKfrCRAREVHVxmSBiIiINGKyQERERBoxWSAiIiKNmCwQERGRRkwWiIiISCMmC0RERKQRkwUiIiLSiMkCERERacRkgUR//PEHxo4diyZNmqBGjRqoWbMm2rVrh6VLl+L27duVeu7Tp0/D3d0dKpUKCoUCK1eu1Po5FAoFQkJCtH7c54mMjIRCoYBCocCxY8fK7BcEAc2bN4dCoUD37t1f6Bxr1qxBZGRkhV5z7NixZ87pRTy5zuTk5HL3e3l5oXHjxlo517OcOHECISEhuHPnTqWeh0huDHQ9AaoaNmzYgKlTp6Jly5b44IMP4OjoiOLiYiQnJ2PdunWIj4/Hvn37Ku3848aNQ0FBAaKiolC7du1K+aUSHx+PBg0aaP24UpmZmWHTpk1lEoK4uDhcvHgRZmZmL3zsNWvWoE6dOhgzZozk17Rr1w7x8fFwdHR84fNWNSdOnMDHH3+MMWPGoFatWrqeDlG1wWSBEB8fjylTpqBnz56Ijo6GUqkU9/Xs2ROBgYGIiYmp1DmcPXsWEyZMQN++fSvtHJ06daq0Y0sxbNgw7NixA19++SXMzc3F8U2bNsHNzQ137959JfMoLi6GQqGAubm5zt8TIno9sA1BCA0NhUKhwFdffaWWKDxhZGQEb29v8evS0lIsXboUrVq1glKphJWVFUaNGoWMjAy113Xv3h1OTk5ISkpC165dYWJigqZNm2Lx4sUoLS0F8P+l60ePHmHt2rViuR4AQkJCxH//05PXXL58WRw7cuQIunfvDktLSxgbG6Nhw4YYPHgw7t+/L8aU14Y4e/YsfHx8ULt2bdSoUQNt27bF1q1b1WKelOu/+eYbfPTRR7C1tYW5uTk8PT1x/vx5aW8ygBEjRgAAvvnmG3EsLy8Pe/bswbhx48p9zccffwxXV1dYWFjA3Nwc7dq1w6ZNm/DPz39r3LgxUlNTERcXJ75/TyozT+a+fft2BAYGon79+lAqlfj777/LtCFu3rwJOzs7dO7cGcXFxeLxz507B1NTU/j5+Um+VqkEQcCaNWvQtm1bGBsbo3bt2hgyZAguXbqkFnfo0CH4+PigQYMGqFGjBpo3b45Jkybh5s2bYkxISAg++OADAECTJk3KtH4aN24MLy8vHDhwAC4uLjA2NoaDgwMOHDgA4PHPlYODA0xNTfHmm2+WaackJydj+PDhaNy4MYyNjdG4cWOMGDECV65cUYt78vN56NAhjB07FhYWFjA1NcWAAQPKXBfR64LJgsyVlJTgyJEjaN++Pezs7CS9ZsqUKZg3bx569uyJ7777DosWLUJMTAw6d+6s9n/eAJCVlYWRI0fivffew3fffYe+ffsiKCgIX3/9NQCgf//+iI+PBwAMGTIE8fHx4tdSXb58Gf3794eRkRE2b96MmJgYLF68GKampnj48OEzX3f+/Hl07twZqampWL16Nfbu3QtHR0eMGTMGS5cuLRM/f/58XLlyBRs3bsRXX32FCxcuYMCAASgpKZE0T3NzcwwZMgSbN28Wx7755hvo6elh2LBhz7y2SZMmYdeuXdi7dy8GDRqE6dOnY9GiRWLMvn370LRpU7i4uIjv39Mto6CgIFy9ehXr1q3D/v37YWVlVeZcderUQVRUFJKSkjBv3jwAwP379/Huu++iYcOGWLdunaTrLCkpwaNHj8ps5X3A7aRJkxAQEABPT09ER0djzZo1SE1NRefOnXHjxg0x7uLFi3Bzc8PatWsRGxuLhQsXIiEhAW+99ZaY2IwfPx7Tp08HAOzdu1d8L9q1ayce5/fff0dQUBDmzZuHvXv3QqVSYdCgQQgODsbGjRsRGhqKHTt2IC8vD15eXigsLFT7XrRs2RIrV67Ejz/+iCVLliAzMxMdO3Ys83MPAP7+/tDT08POnTuxcuVKJCYmonv37ryfgl5PAslaVlaWAEAYPny4pPi0tDQBgDB16lS18YSEBAGAMH/+fHHM3d1dACAkJCSoxTo6Ogq9e/dWGwMgTJs2TW0sODhYKO9HdMuWLQIAIT09XRAEQdi9e7cAQEhJSdE4dwBCcHCw+PXw4cMFpVIpXL16VS2ub9++gomJiXDnzh1BEATh6NGjAgChX79+anG7du0SAAjx8fEaz/tkvklJSeKxzp49KwiCIHTs2FEYM2aMIAiC0Lp1a8Hd3f2ZxykpKRGKi4uFTz75RLC0tBRKS0vFfc967ZPzdevW7Zn7jh49qja+ZMkSAYCwb98+YfTo0YKxsbHwxx9/aLzGf16npq1Ro0ZifHx8vABA+OKLL9SOc+3aNcHY2FiYO3duuecpLS0ViouLhStXrggAhP/85z/ivmXLlqn9bPxTo0aNBGNjYyEjI0McS0lJEQAI9erVEwoKCsTx6OhoAYDw3XffPfN6Hz16JOTn5wumpqbCqlWryrwP77zzjlr8r7/+KgAQPv3002cek6iqYmWBKuTo0aMAUOZGujfffBMODg44fPiw2riNjQ3efPNNtbE33nijTOn2ZbRt2xZGRkaYOHEitm7dKrnUe+TIEXh4eJSpqIwZMwb3798vU+H4ZysGeHwdACp0Le7u7mjWrBk2b96MM2fOICkp6ZktiCdz9PT0hEqlgr6+PgwNDbFw4ULcunUL2dnZks87ePBgybEffPAB+vfvjxEjRmDr1q0IDw+Hs7Oz5Ndv27YNSUlJZba33npLLe7AgQNQKBR477331CoQNjY2aNOmjdoqjezsbEyePBl2dnYwMDCAoaEhGjVqBABIS0uTPLe2bduifv364tcODg4AHrfMTExMyoz/83ubn5+PefPmoXnz5jAwMICBgQFq1qyJgoKCcucwcuRIta87d+6MRo0aif8NEb1OeIOjzNWpUwcmJiZIT0+XFH/r1i0AQL169crss7W1LfOL09LSskycUqlUK+++rGbNmuGnn37C0qVLMW3aNBQUFKBp06aYMWMGZs6c+czX3bp165nX8WT/Pz19LU/u76jItSgUCowdOxarV6/GgwcP0KJFC3Tt2rXc2MTERPTq1Qvdu3fHhg0b0KBBAxgZGSE6OhqfffZZhc5b3nVqmuOYMWPw/fffw8bGpsL3Kjg4OKBDhw5lxlUqFa5duyZ+fePGDQiCAGtr63KP07RpUwCP75Hp1asXrl+/jgULFsDZ2RmmpqYoLS1Fp06dKvQ+WFhYqH1tZGSkcfzBgwfimK+vLw4fPowFCxagY8eOMDc3h0KhQL9+/cqdg42NTbljT/9cEb0OmCzInL6+Pjw8PPDDDz8gIyPjuUsLn/zCzMzMLBN7/fp11KlTR2tzq1GjBgCgqKhI7cbL8vrDXbt2RdeuXVFSUoLk5GSEh4cjICAA1tbWGD58eLnHt7S0RGZmZpnx69evA4BWr+WfxowZg4ULF2LdunX47LPPnhkXFRUFQ0NDHDhwQHwvACA6OrrC5yzvRtFnyczMxLRp09C2bVukpqZizpw5WL16dYXP+Tx16tSBQqHAL7/8Uu6NtU/Gzp49i99//x2RkZEYPXq0uP/vv//W+pyeJS8vDwcOHEBwcDA+/PBDcbyoqOiZzyDJysoqd6x58+aVNk+iysI2BCEoKAiCIGDChAnl3hBYXFyM/fv3AwB69OgBAOINik8kJSUhLS0NHh4eWpvXkzv6//jjD7XxJ3Mpj76+PlxdXfHll18CAH777bdnxnp4eODIkSNicvDEtm3bYGJiUmnLCuvXr48PPvgAAwYMUPvl9zSFQgEDAwPo6+uLY4WFhdi+fXuZWG1Va0pKSjBixAgoFAr88MMPCAsLQ3h4OPbu3fvSx36al5cXBEHAf//7X3To0KHM9qT18STReTqhWL9+fZljvki1RwqFQgFBEMrMYePGjc+8wXXHjh1qX584cQJXrlx54QdvEekSKwsk3mU+depUtG/fHlOmTEHr1q1RXFyM06dP46uvvoKTkxMGDBiAli1bYuLEiQgPD4eenh769u2Ly5cvY8GCBbCzs8OsWbO0Nq9+/frBwsIC/v7++OSTT2BgYIDIyEi1UjYArFu3DkeOHEH//v3RsGFDPHjwQFxx4Onp+czjBwcH48CBA3j77bexcOFCWFhYYMeOHfj++++xdOlSqFQqrV3L0xYvXvzcmP79+2P58uXw9fXFxIkTcevWLXz++efl/hXu7OyMqKgofPvtt2jatClq1KhRofsMnggODsYvv/yC2NhY2NjYIDAwEHFxcfD394eLiwuaNGlS4WM+S5cuXTBx4kSMHTsWycnJ6NatG0xNTZGZmYnjx4/D2dkZU6ZMQatWrdCsWTN8+OGHEAQBFhYW2L9/Pw4dOlTmmE+uedWqVRg9ejQMDQ3RsmXLl3rgFfB4JUu3bt2wbNky1KlTB40bN0ZcXBw2bdr0zIc/JScnY/z48Xj33Xdx7do1fPTRR6hfvz6mTp36UnMh0gmd3l5JVUpKSoowevRooWHDhoKRkZFgamoquLi4CAsXLhSys7PFuJKSEmHJkiVCixYtBENDQ6FOnTrCe++9J1y7dk3teO7u7kLr1q3LnGf06NFqd8ULQvmrIQRBEBITE4XOnTsLpqamQv369YXg4GBh48aNane8x8fHC++8847QqFEjQalUCpaWloK7u3uZO9nx1GoIQRCEM2fOCAMGDBBUKpVgZGQktGnTRtiyZYtazJNVA//+97/VxtPT0wUAZeKf9s/VEJqUt6Jh8+bNQsuWLQWlUik0bdpUCAsLEzZt2lTmjv/Lly8LvXr1EszMzNRWHTxr7v/c92Q1RGxsrKCnp1fmPbp165bQsGFDoWPHjkJRUdELX2f//v3LfN+fXKOrq6tgamoqGBsbC82aNRNGjRolJCcnizHnzp0TevbsKZiZmQm1a9cW3n33XeHq1avlfk+DgoIEW1tbQU9PT+36GjVqJPTv37/M+cv72XvyvV22bJk4lpGRIQwePFioXbu2YGZmJvTp00c4e/as0KhRI2H06NFl3ofY2FjBz89PqFWrlmBsbCz069dPuHDhwjPfP6KqTCEI5Sx+JiKiFxIZGYmxY8ciKSmp3Bs9iV5HvGeBiIiINGKyQERERBqxDUFEREQasbJAREREGjFZICIiIo2YLBAREZFGTBaIiIhIo2r5BEdjl/d1PQWiSpebFKHrKRBVuhqV/FtKm78vCk9X3/8mq2WyQEREJImCBXYp+C4RERGRRqwsEBGRfFXg49vljMkCERHJF9sQkvBdIiIiIo1YWSAiIvliG0ISJgtERCRfbENIwneJiIiINGJlgYiI5IttCEmYLBARkXyxDSEJ3yUiIiLSiJUFIiKSL7YhJGFlgYiI5Euhp72tAkJCQqBQKNQ2Gxsbcb8gCAgJCYGtrS2MjY3RvXt3pKamqh2jqKgI06dPR506dWBqagpvb29kZGSoxeTm5sLPzw8qlQoqlQp+fn64c+dOhd8mJgtEREQ60Lp1a2RmZorbmTNnxH1Lly7F8uXLERERgaSkJNjY2KBnz564d++eGBMQEIB9+/YhKioKx48fR35+Pry8vFBSUiLG+Pr6IiUlBTExMYiJiUFKSgr8/PwqPFe2IYiISL502IYwMDBQqyY8IQgCVq5ciY8++giDBg0CAGzduhXW1tbYuXMnJk2ahLy8PGzatAnbt2+Hp6cnAODrr7+GnZ0dfvrpJ/Tu3RtpaWmIiYnByZMn4erqCgDYsGED3NzccP78ebRs2VLyXFlZICIi+dJiG6KoqAh3795V24qKip556gsXLsDW1hZNmjTB8OHDcenSJQBAeno6srKy0KtXLzFWqVTC3d0dJ06cAACcOnUKxcXFajG2trZwcnISY+Lj46FSqcREAQA6deoElUolxkjFZIGIiEgLwsLCxHsDnmxhYWHlxrq6umLbtm348ccfsWHDBmRlZaFz5864desWsrKyAADW1tZqr7G2thb3ZWVlwcjICLVr19YYY2VlVebcVlZWYoxUbEMQEZF8abENERQUhNmzZ6uNKZXKcmP79u0r/tvZ2Rlubm5o1qwZtm7dik6dOv1vaupzEwShzNjTno4pL17KcZ7GygIREcmXFtsQSqUS5ubmatuzkoWnmZqawtnZGRcuXBDvY3j6r//s7Gyx2mBjY4OHDx8iNzdXY8yNGzfKnCsnJ6dM1eJ5mCwQERHpWFFREdLS0lCvXj00adIENjY2OHTokLj/4cOHiIuLQ+fOnQEA7du3h6GhoVpMZmYmzp49K8a4ubkhLy8PiYmJYkxCQgLy8vLEGKnYhiAiIvnS0eOe58yZgwEDBqBhw4bIzs7Gp59+irt372L06NFQKBQICAhAaGgo7O3tYW9vj9DQUJiYmMDX1xcAoFKp4O/vj8DAQFhaWsLCwgJz5syBs7OzuDrCwcEBffr0wYQJE7B+/XoAwMSJE+Hl5VWhlRAAkwUiIpIzPd0snczIyMCIESNw8+ZN1K1bF506dcLJkyfRqFEjAMDcuXNRWFiIqVOnIjc3F66uroiNjYWZmZl4jBUrVsDAwABDhw5FYWEhPDw8EBkZCX19fTFmx44dmDFjhrhqwtvbGxERERWer0IQBOElr7nKMXZ5X9dTIKp0uUkV/w+e6HVTo5L/pDV+e5HWjlV4dIHWjlXVsLJARETyxU+dlITJAhERyRc/SEoSplRERESkESsLREQkX2xDSMJkgYiI5IttCEmYUhEREZFGrCwQEZF8sQ0hCZMFIiKSL7YhJGFKRURERBqxskBERPLFNoQkTBaIiEi+2IaQhCkVERERacTKAhERyRfbEJIwWSAiIvliG0ISplRERESkESsLREQkX2xDSMJkgYiI5IvJgiR8l4iIiEgjVhaIiEi+eIOjJEwWiIhIvtiGkITvEhEREWnEygIREckX2xCSMFkgIiL5YhtCEr5LREREpBErC0REJF9sQ0jCZIGIiGRLwWRBErYhiIiISCNWFoiISLZYWZCGyQIREckXcwVJ2IYgIiIijVhZICIi2WIbQhomC0REJFtMFqRhG4KIiIg0YmWBiIhki5UFaZgsEBGRbDFZkIZtCCIiItKIlQUiIpIvFhYkYbJARESyxTaENGxDEBERkUasLBARkWyxsiANkwUiIpItJgvSsA1BREREGrGyQEREssXKgjRMFoiISL6YK0jCNgQRERFpxMoCERHJFtsQ0jBZICIi2WKyIA3bEERERKQRKwtERCRbrCxIw2SBiIjki7mCJGxDEBERkUasLBARkWyxDSENkwUiIpItJgvSsA1BREREGrGyQEREssXKgjRMFoiISLaYLEjDNgQRERFpxMoCERHJFwsLkjBZICIi2WIbQhq2IYiIiEgjVhaIiEi2WFmQhskCERHJFpMFadiGICIiIo1YWSAiIvliYUESVhaIiEi2FAqF1rYXFRYWBoVCgYCAAHFMEASEhITA1tYWxsbG6N69O1JTU9VeV1RUhOnTp6NOnTowNTWFt7c3MjIy1GJyc3Ph5+cHlUoFlUoFPz8/3Llzp8JzZLJARESkI0lJSfjqq6/wxhtvqI0vXboUy5cvR0REBJKSkmBjY4OePXvi3r17YkxAQAD27duHqKgoHD9+HPn5+fDy8kJJSYkY4+vri5SUFMTExCAmJgYpKSnw8/Or8DyrXLIgCAIEQdD1NIiISAZ0WVnIz8/HyJEjsWHDBtSuXVscFwQBK1euxEcffYRBgwbByckJW7duxf3797Fz504AQF5eHjZt2oQvvvgCnp6ecHFxwddff40zZ87gp59+AgCkpaUhJiYGGzduhJubG9zc3LBhwwYcOHAA58+fr9Bcq0yysG3bNjg7O8PY2BjGxsZ44403sH37dl1PSzY+mtQPhacj1Lb0Q6EAAAMDPXw6wwdJu+bj5okvcCn2M2xc5Id6dVVqxwj/aDhSvwvG7fjluHokDLtWTESLxtZlztXnrdb4edsc3I5fjmtHFiPq8/Gv5BqJpLhx4waC5s1Bt86ucG3fBkMH+eBc6llx//2CAoR++gl69uiGN9u9gYED+mJX1E4dzphehjaThaKiIty9e1dtKyoqeua5p02bhv79+8PT01NtPD09HVlZWejVq5c4plQq4e7ujhMnTgAATp06heLiYrUYW1tbODk5iTHx8fFQqVRwdXUVYzp16gSVSiXGSFUlbnBcvnw5FixYgPfffx9dunSBIAj49ddfMXnyZNy8eROzZs3S9RRlIfXv6+g/OVz8uqT0cYXHpIYR2jrYYfGGH/DHX/9FbXMTLJszGP9eOQlvjVwqxp9Ou4aoH5JwLTMXFioTfDS5Pw6smYZWXsEo/d+xBnq0xZcLRiA4Yj+OJf4FhQJwsrd9tRdK9Ax38/Iw5r0R6PCmK75ctwEWlhbIuHYNZmbmYsyyJWFISkxA6OJlsK1fH/G//orQTz9GXSsrvN3DU8PRqboLCwvDxx9/rDYWHByMkJCQMrFRUVH47bffkJSUVGZfVlYWAMDaWv2PLWtra1y5ckWMMTIyUqtIPIl58vqsrCxYWVmVOb6VlZUYI1WVSBbCw8Oxdu1ajBo1Shzz8fFB69atERISwmThFXlUUoobt+6VGb+b/wBeUyLUxmYv+TeO75gLO5vauJaVCwDYvPdXcf/VzNv4+Mv9SNo1H41sLZGecRP6+nr4/IPBmL8yGluj48XYC1eyK+mKiCpm86YNsLaxwaLPwsSx+vUbqMX8/nsKBvgMRMc3H/+1NmToMOz+97dIPXuWycJrSJvPWQgKCsLs2bPVxpRKZZm4a9euYebMmYiNjUWNGjUkz00QhOfO9+mY8uKlHOdpVaINkZmZic6dO5cZ79y5MzIzM3UwI3lq3rAuLsV+hrQDIdi2eCwa17d8Zqy5mTFKS0tx515huftNahhhlHcnpGfcRMb/kgmXVnaob10bpaUC4r+Zh0uxnyE6YgocmtpUyvUQVVTc0SNo3doJc2bNQPeubhg6eCD2/HuXWoxLu3aIO3oEN27cgCAISEw4iSuX09G5y1s6mjW9FIX2NqVSCXNzc7WtvGTh1KlTyM7ORvv27WFgYAADAwPExcVh9erVMDAwECsKT//1n52dLe6zsbHBw4cPkZubqzHmxo0bZc6fk5NTpmrxPFUiWWjevDl27dpVZvzbb7+Fvb29xteW1yMSSks0vobKSjp7GeMXbMeAqV9i6qJvYG1pjqORgbBQmZaJVRoZYNEMH3z7QzLuFTxQ2zfx3a7I+fUL3Ipfjp6dHdF/SgSKHz3+fjRpUAcA8K/J/bBk448YPHMd7twtROzGANQ2N6n8iyR6joyMa9j17Tdo2Kgx1n61Ce8OG44lYZ9i/3+ixZgPg/6Fps2ao1ePbujQ1glTJ43H/AXBaNe+g+4mTq8VDw8PnDlzBikpKeLWoUMHjBw5EikpKWjatClsbGxw6NAh8TUPHz5EXFyc+Id1+/btYWhoqBaTmZmJs2fPijFubm7Iy8tDYmKiGJOQkIC8vLxy/0DXpEq0IT7++GMMGzYMP//8M7p06QKFQoHjx4/j8OHD5SYR/1Rej0jfuiMM671ZmVOudmJ/PSf+O/VvIOH3dKTuD8F7A1yx+usj4j4DAz1sXzwWegoFZoaV/d5E/ZCEwwl/wqaOOQJGeeLrJePQY+xyFD18BL3/lb2WbPwR0YdTAAATg7/G3z8uwqCeLti059cyxyN6lUpLBbR2csKMgMelZAcHR1z8+2/s+vYbDPAZCADYuWM7/vgjBasi1sLW1hankpMRuuhj1K1rhU5uFfs/YNI9XTzu2czMDE5OTmpjpqamsLS0FMcDAgIQGhoKe3t72NvbIzQ0FCYmJvD19QUAqFQq+Pv7IzAwEJaWlrCwsMCcOXPg7Ows3jDp4OCAPn36YMKECVi/fj0AYOLEifDy8kLLli0rNOcqkSwMHjwYCQkJWL58OaKjoyEIAhwdHZGYmAgXFxeNry2vR2TVdV5lTlcW7j94iNS/r6NZw7rimIGBHnYs8Uej+pboOzG8TFUBeHx/w938B7h4NQeJf1xG5s9L4dOjDXbFnELmzTwAwJ+X/r+19LD4ES5n3IKdjUXlXxTRc9StWxdNmzVTG2vatCl+OvQjAODBgwdYvXIFVqyOQDf37gCAFi1b4fz5NGzdsonJwmuoqn42xNy5c1FYWIipU6ciNzcXrq6uiI2NhZmZmRizYsUKGBgYYOjQoSgsLISHhwciIyOhr68vxuzYsQMzZswQV014e3sjIiKizPmep0okC8DjksqOHTsq/DqlUlmmJ6TQ039GNEllZGiAVk2s8evpvwH8f6LQrGFd9Jm4GrfzCiQdRwEFjAwf/5idTruGB0XFsG9sjRMpl8TjNrS1wNXM25VzIUQV0NalHS6np6uNXbl8Gba29QEAjx49wqNHxdDTU/8Fo6enj1I+H4ZewrFjx9S+VigUCAkJKXclxRM1atRAeHg4wsPDnxljYWGBr7/++qXnp9NkQU9P77lZnUKhwKNHj17RjOQrbNY7+P7nM7iWmQsri5qYN74PzExrYMf+BOjr62HnsvFwaWWHQTPXQV9PAWvLx9nt7bz7KH5Ugsb1LTGkd3scjk/Dzdx82FrVQuAYTxQWFePH448fUXqv4AE27j6OBZP7ISMrF1czb2PW6Mflsr2HftPZtRM98d6o0Rj93ghs/GodevXui7Nn/sDu3buwMOQTAEDNmjXRoeObWP75MiiVNVDP1hankpJw4LtozJn7oY5nTy+iihYWqhyFoMPHJf7nP/955r4TJ04gPDwcgiCgsLD8O+6fxdjl/ZedmuxsWzwWb7VrDstapriZm4/EM5fx8ZoD+PNSFhrWs8D5g5+U+7pe41fhl1MXUK+uCmsW+sLFwQ61zU2Qfesejv/2N0K/+kFtaaSBgR4WTffBiP4dYaw0RNLZK/hg2W6kXarYml8CcpMqXkqk54s7dhSrVy7H1SuXUb9BA/iNGovB7w4V99/MycGqlcsRf+I47ubloZ6tLQYPGQa/0WOqbEn7dVajkv+ktf8gRmvHurCsj9aOVdXoNFkoz59//omgoCDs378fI0eOxKJFi9CwYcMKHYPJAskBkwWSAyYLVUOVWDoJANevX8eECRPwxhtv4NGjR0hJScHWrVsrnCgQERFJpVBob6vOdJ4s5OXlYd68eWjevDlSU1Nx+PBh7N+/v8yyEiIiIm2rCh9R/TrQ6Q2OS5cuxZIlS2BjY4NvvvkGPj4+upwOERERlUOnycKHH34IY2NjNG/eHFu3bsXWrVvLjdu7d+8rnhkREclBNS8IaI1Ok4VRo0ZV+9INERFVXU8/M4PKp9NkITIyUpenJyIiIgmqzBMciYiIXjUWt6XR+WoIIiIiqtpYWSAiItnifXPSMFkgIiLZYq4gDdsQREREpBErC0REJFtsQ0jDZIGIiGSLyYI0bEMQERGRRqwsEBGRbLGwIA2TBSIiki22IaRhG4KIiIg0YmWBiIhki4UFaZgsEBGRbLENIQ3bEERERKQRKwtERCRbLCxIw2SBiIhki20IadiGICIiIo1YWSAiItliYUEaJgtERCRbbENIwzYEERERacTKAhERyRYLC9IwWSAiItliG0IatiGIiIhII1YWiIhItlhYkIbJAhERyRbbENKwDUFEREQasbJARESyxcKCNEwWiIhIttiGkIZtCCIiItKIlQUiIpItVhakYbJARESyxVxBGrYhiIiISCNWFoiISLbYhpCGyQIREckWcwVp2IYgIiIijVhZICIi2WIbQhomC0REJFvMFaRhG4KIiIg0YmWBiIhkS4+lBUmYLBARkWwxV5CGbQgiIiLSiJUFIiKSLa6GkIbJAhERyZYecwVJ2IYgIiIijVhZICIi2WIbQhomC0REJFvMFaRhG4KIiIg0YmWBiIhkSwGWFqRgskBERLLF1RDSsA1BREREGrGyQEREssXVENIwWSAiItliriAN2xBERESkESsLREQkW/yIamlYWSAiItlSKLS3VcTatWvxxhtvwNzcHObm5nBzc8MPP/wg7hcEASEhIbC1tYWxsTG6d++O1NRUtWMUFRVh+vTpqFOnDkxNTeHt7Y2MjAy1mNzcXPj5+UGlUkGlUsHPzw937typ8PvEZIGIiOgVa9CgARYvXozk5GQkJyejR48e8PHxEROCpUuXYvny5YiIiEBSUhJsbGzQs2dP3Lt3TzxGQEAA9u3bh6ioKBw/fhz5+fnw8vJCSUmJGOPr64uUlBTExMQgJiYGKSkp8PPzq/B8FYIgCC9/2VWLscv7up4CUaXLTYrQ9RSIKl2NSm6WD9nym9aOtXtsu5d6vYWFBZYtW4Zx48bB1tYWAQEBmDdvHoDHVQRra2ssWbIEkyZNQl5eHurWrYvt27dj2LBhAIDr16/Dzs4OBw8eRO/evZGWlgZHR0ecPHkSrq6uAICTJ0/Czc0Nf/75J1q2bCl5bqwsEBGRbGmzDVFUVIS7d++qbUVFRc+dQ0lJCaKiolBQUAA3Nzekp6cjKysLvXr1EmOUSiXc3d1x4sQJAMCpU6dQXFysFmNrawsnJycxJj4+HiqVSkwUAKBTp05QqVRijFRMFoiIiLQgLCxMvDfgyRYWFvbM+DNnzqBmzZpQKpWYPHky9u3bB0dHR2RlZQEArK2t1eKtra3FfVlZWTAyMkLt2rU1xlhZWZU5r5WVlRgjFVdDEBGRbGlzNURQUBBmz56tNqZUKp8Z37JlS6SkpODOnTvYs2cPRo8ejbi4OHH/0w+MEgThuQ+RejqmvHgpx3kakwUiIpItbS6cVCqVGpODpxkZGaF58+YAgA4dOiApKQmrVq0S71PIyspCvXr1xPjs7Gyx2mBjY4OHDx8iNzdXrbqQnZ2Nzp07izE3btwoc96cnJwyVYvnYRuCiIioChAEAUVFRWjSpAlsbGxw6NAhcd/Dhw8RFxcnJgLt27eHoaGhWkxmZibOnj0rxri5uSEvLw+JiYliTEJCAvLy8sQYqVhZICIi2dLVZ0PMnz8fffv2hZ2dHe7du4eoqCgcO3YMMTExUCgUCAgIQGhoKOzt7WFvb4/Q0FCYmJjA19cXAKBSqeDv74/AwEBYWlrCwsICc+bMgbOzMzw9PQEADg4O6NOnDyZMmID169cDACZOnAgvL68KrYQAmCwQEZGM6eojqm/cuAE/Pz9kZmZCpVLhjTfeQExMDHr27AkAmDt3LgoLCzF16lTk5ubC1dUVsbGxMDMzE4+xYsUKGBgYYOjQoSgsLISHhwciIyOhr68vxuzYsQMzZswQV014e3sjIqLiy675nAWi1xSfs0ByUNnPWRi5PUVrx9rh11Zrx6pqWFkgIiLZ4kdUSyMpWfjuu+8kH9Db2/uFJ0NERPQqMVeQRlKyMHDgQEkHUygUas+kJiIiotefpGShtLS0sudBRET0yrENIQ3vWSAiItnS1WqI180LJQsFBQWIi4vD1atX8fDhQ7V9M2bM0MrEiIiIqGqocLJw+vRp9OvXD/fv30dBQQEsLCxw8+ZNmJiYwMrKiskCERG9NtiGkKbCj3ueNWsWBgwYgNu3b8PY2BgnT57ElStX0L59e3z++eeVMUciIqJKodDiVp1VOFlISUlBYGAg9PX1oa+vj6KiItjZ2WHp0qWYP39+ZcyRiIiIdKjCyYKhoaFYtrG2tsbVq1cBPH5O9ZN/ExERvQ70FAqtbdVZhe9ZcHFxQXJyMlq0aIG3334bCxcuxM2bN7F9+3Y4OztXxhyJiIgqRTX/Ha81Fa4shIaGip+vvWjRIlhaWmLKlCnIzs7GV199pfUJEhERkW5VuLLQoUMH8d9169bFwYMHtTohIiKiV4WrIaThQ5mIiEi2mCtIU+FkoUmTJhozsUuXLr3UhIiIiKhqqXCyEBAQoPZ1cXExTp8+jZiYGHzwwQfamhcREVGlq+6rGLSlwsnCzJkzyx3/8ssvkZyc/NITIiIielWYK0hT4dUQz9K3b1/s2bNHW4cjIiKiKkJrNzju3r0bFhYW2jocERFRpeNqCGle6KFM/3xzBUFAVlYWcnJysGbNGq1O7kX9dfgLXU+BqNKVlAq6ngLRK1C5v8y1Vl6v5iqcLPj4+KglC3p6eqhbty66d++OVq1aaXVyREREpHsVThZCQkIqYRpERESvHtsQ0lS4AqOvr4/s7Owy47du3YK+vr5WJkVERPQq6Cm0t1VnFU4WBKH8PmlRURGMjIxeekJERERUtUhuQ6xevRrA45LNxo0bUbNmTXFfSUkJfv75Z96zQEREr5XqXhHQFsnJwooVKwA8riysW7dOreVgZGSExo0bY926ddqfIRERUSXhPQvSSE4W0tPTAQBvv/029u7di9q1a1fapIiIiKjqqPBqiKNHj1bGPIiIiF45tiGkqfANjkOGDMHixYvLjC9btgzvvvuuViZFRET0KigU2tuqswonC3Fxcejfv3+Z8T59+uDnn3/WyqSIiIio6qhwGyI/P7/cJZKGhoa4e/euViZFRET0KvAjqqWpcGXByckJ3377bZnxqKgoODo6amVSREREr4KeFrfqrMKVhQULFmDw4MG4ePEievToAQA4fPgwdu7cid27d2t9gkRERKRbFU4WvL29ER0djdDQUOzevRvGxsZo06YNjhw5AnNz88qYIxERUaVgF0KaCicLANC/f3/xJsc7d+5gx44dCAgIwO+//46SkhKtTpCIiKiy8J4FaV64zXLkyBG89957sLW1RUREBPr164fk5GRtzo2IiIiqgApVFjIyMhAZGYnNmzejoKAAQ4cORXFxMfbs2cObG4mI6LXDwoI0kisL/fr1g6OjI86dO4fw8HBcv34d4eHhlTk3IiKiSsWPqJZGcmUhNjYWM2bMwJQpU2Bvb1+ZcyIiIqIqRHJl4ZdffsG9e/fQoUMHuLq6IiIiAjk5OZU5NyIiokqlp1BobavOJCcLbm5u2LBhAzIzMzFp0iRERUWhfv36KC0txaFDh3Dv3r3KnCcREZHW8bMhpKnwaggTExOMGzcOx48fx5kzZxAYGIjFixfDysoK3t7elTFHIiIi0qGXekJly5YtsXTpUmRkZOCbb77R1pyIiIheCd7gKM0LPZTpafr6+hg4cCAGDhyojcMRERG9EgpU89/yWlLdP/uCiIiIXpJWKgtERESvo+rePtAWJgtERCRbTBakYRuCiIiINGJlgYiIZEtR3R+QoCVMFoiISLbYhpCGbQgiIiLSiJUFIiKSLXYhpGGyQEREslXdPwBKW9iGICIiIo1YWSAiItniDY7SMFkgIiLZYhdCGrYhiIiISCNWFoiISLb0+KmTkjBZICIi2WIbQhq2IYiIiEgjVhaIiEi2uBpCGiYLREQkW3wokzRsQxAREZFGrCwQEZFssbAgDSsLREQkW3oKhda2iggLC0PHjh1hZmYGKysrDBw4EOfPn1eLEQQBISEhsLW1hbGxMbp3747U1FS1mKKiIkyfPh116tSBqakpvL29kZGRoRaTm5sLPz8/qFQqqFQq+Pn54c6dOxV7nyoUTURERC8tLi4O06ZNw8mTJ3Ho0CE8evQIvXr1QkFBgRizdOlSLF++HBEREUhKSoKNjQ169uyJe/fuiTEBAQHYt28foqKicPz4ceTn58PLywslJSVijK+vL1JSUhATE4OYmBikpKTAz8+vQvNVCIIgvPxlVy3XbhfpegpElc6ippGup0BU6UyNKrdPsDnpqtaONa5jwxd+bU5ODqysrBAXF4du3bpBEATY2toiICAA8+bNA/C4imBtbY0lS5Zg0qRJyMvLQ926dbF9+3YMGzYMAHD9+nXY2dnh4MGD6N27N9LS0uDo6IiTJ0/C1dUVAHDy5Em4ubnhzz//RMuWLSXNj5UFIiKSLT0tbkVFRbh7967aVlQk7Y/XvLw8AICFhQUAID09HVlZWejVq5cYo1Qq4e7ujhMnTgAATp06heLiYrUYW1tbODk5iTHx8fFQqVRiogAAnTp1gkqlEmOkvk9ERET0ksLCwsT7Ap5sYWFhz32dIAiYPXs23nrrLTg5OQEAsrKyAADW1tZqsdbW1uK+rKwsGBkZoXbt2hpjrKysypzTyspKjJGCqyGIiEi2FFpcDhEUFITZs2erjSmVyue+7v3338cff/yB48ePP3d+giA8d85Px5QXL+U4/8TKAhERyZZCi5tSqYS5ubna9rxkYfr06fjuu+9w9OhRNGjQQBy3sbEBgDJ//WdnZ4vVBhsbGzx8+BC5ubkaY27cuFHmvDk5OWWqFpowWSAiInrFBEHA+++/j7179+LIkSNo0qSJ2v4mTZrAxsYGhw4dEscePnyIuLg4dO7cGQDQvn17GBoaqsVkZmbi7NmzYoybmxvy8vKQmJgoxiQkJCAvL0+MkYJtCCIiki1dPe552rRp2LlzJ/7zn//AzMxMrCCoVCoYGxtDoVAgICAAoaGhsLe3h729PUJDQ2FiYgJfX18x1t/fH4GBgbC0tISFhQXmzJkDZ2dneHp6AgAcHBzQp08fTJgwAevXrwcATJw4EV5eXpJXQgBMFoiISMZ09QDHtWvXAgC6d++uNr5lyxaMGTMGADB37lwUFhZi6tSpyM3NhaurK2JjY2FmZibGr1ixAgYGBhg6dCgKCwvh4eGByMhI6OvrizE7duzAjBkzxFUT3t7eiIiIqNB8+ZwFotcUn7NAclDZz1nYcSrj+UESjWzf4PlBrylWFoiISLb42RDSMFkgIiLZ0ubSyeqMqyGIiIhII1YWiIhItvgXszRMFoiISLbYhpCGSRURERFpxMoCERHJFusK0jBZICIi2WIbQhq2IYiIiEgjVhaIiEi2+BezNEwWiIhIttiGkIZJFREREWnEygIREckW6wrSMFkgIiLZYhdCGrYhiIiISCNWFoiISLb02IiQhMkCERHJFtsQ0rANQURERBqxskBERLKlYBtCEiYLREQkW2xDSMM2BBEREWnEygIREckWV0NIw2SBiIhki20IadiGICIiIo1YWSAiItliZUEaJgtERCRbXDopDdsQREREpBErC0REJFt6LCxIwmSBiIhki20IadiGICIiIo1YWSAiItniaghpdFpZKCwsxP3798Wvr1y5gpUrVyI2NlaHsyIiIrlQaPF/1ZlOkwUfHx9s27YNAHDnzh24urriiy++gI+PD9auXavLqREREdH/6DRZ+O2339C1a1cAwO7du2FtbY0rV65g27ZtWL16tS6nRkREMqCn0N5Wnen0noX79+/DzMwMABAbG4tBgwZBT08PnTp1wpUrV3Q5NSIikoHq3j7QFp0mC82bN0d0dDTeeecd/Pjjj5g1axYAIDs7G+bm5rqcGgG4mX0DG9asRGL8cTwsKkKDho0QOP9jtGjlCADYunENjh2KQU52FgwMDWHf0hHjJk+HQ+s3AAB38/KwdeManEo8gZwbN2Beqxa6dOuBMROnoWZNM11eGpHoVHIStkVuQtq5VNzMycEXKyPwtoenWsylSxexesXn+C05CaWlpWja3B5LPl+BevVskZd3B+u+DMfJ+F9xIysLtWrVRvceHpjy/kzxjyGi151Ok4WFCxfC19cXs2bNQo8ePeDm5gbgcZXBxcVFl1OTvXt372LmpNFo274jwpavQS0LC1zPuKb2S76BXSO8Hzgf9eo3wMOiB9gTtR3zZk7Gtn8fQK3aFrh1Mxu3bmZj0vuBaNSkGW5kXcfKpZ/i1s1sBIcu1+HVEf2/B4WFaNGiFbwHDsIHs2aU2X/t2lX4j/KFz6AhmDx1OmrWNEN6+kUojZQAgJzsbOTkZCMgcC6aNmuOzOvXEbooGDk52Vi2nO3Uqo6rIaRRCIIg6HICWVlZyMzMRJs2baCn9/gWisTERJibm6NVq1YvdMxrt4u0OUVZ2rBmJVL/OI2V67ZKfk1BQT58PDtj6eqv0K5jp3Jj4g7HYvHHQThwJAH6Bly5+zIsahrpegrVTjvnVmUqCx9+MBsGBgb4NGyp5OMc+jEG/wr6AL8mnoYBf85fiqlR5f42//VCrtaO1cW+ttaOVdXo/KFMNjY2MDMzw6FDh1BYWAgA6Nix4wsnCqQd8b8cQ4tWrfHJ/EAM6eeOSaOG4vv/7H5mfHFxMb6P3g3TmmZoZt/ymXEFBfdgYlqTiQK9FkpLS3H852No1Kgxpk7yh4d7Z4zyHYqjh3/S+Lr8/HswrVmTiQJVGzpNFm7dugUPDw+0aNEC/fr1Q2ZmJgBg/PjxCAwMlHSMoqIi3L17V20rKmJl4WVlXs/A/n27UN+uIcJWrMOAd97Fl8uXIPbgd2pxJ4/HwauHK/q5d8CeqK+xZNV6qGqVn13n5d3B11u+Qv+BQ17FJRC9tNu3b+H+/fvYsnkDOnfpijXrN+HtHp6YM2s6TiUllvuaO3dysWH9WgweMuwVz5ZehJ5CobWtOtNpsjBr1iwYGhri6tWrMDExEceHDRuGmJgYSccICwuDSqVS275cKb1cSOUTSkth38IB/lNmwr6lA7zeeRf9fAZj/75danFt2nfE+q3/xqqvtqFjpy749F9zkHv7VpnjFRTk46PAaWjUuClG+U9+VZdB9FKE0lIAQPfuPfDeqDFo2coBY8dPRFf37tj976gy8fn5+ZgxbTKaNm2GiVOmverp0gtQaHGrznSaLMTGxmLJkiVo0KCB2ri9vb3kpZNBQUHIy8tT26YFzK2M6cqKRZ26aNSkqdpYw8ZNkJ2VpTZmbGyC+nYN4ejUBnM++hj6+gb4Yf8+tZj7BQUICpgCY2MTfLx4JQwMDCt9/kTaUKt2bRgYGKBps+Zq402aNEPW/yqhTxQU5OP9yeNhYmyCL1ZFwNCQP+dUfei0oVZQUKBWUXji5s2bUCqVko6hVCrLxOY9YhviZbV2botrVy+rjWVcvQJrm3oaXycIAoqLH4pfFxTk48OAyTA0NMKiZathJPH7SlQVGBoawbG1Ey5fTlcbv3rlMurVsxW/zs/Px7RJ/jAyMsKK8DWS//+LqoDqXhLQEp1UFjIyMgAAXbt2FR/3DAAKhQKlpaVYtmwZ3n77bV1Mjf5n8HA/pJ09g52RG/Dfa1dx+MfvcfA/u+EzZDgAoLDwPjatXYVzZ3/HjczruHD+HL4IDUZOzg249+gF4HFFYd7MSXhQWIg58z/G/YIC3L51E7dv3URJSYkuL49IdP9+Ac7/mYbzf6YBAP773wyc/zMNmZnXAQCjxvojNuYH7N29C1evXkHUzq/xc9xRvDvcF8DjhHjqJH8UFhZi4SefoaAgHzdv5uDmzRz+nL8G+NkQ0uhk6WStWrUQHh6ODh06wN3dHe3bt8eRI0fg7e2N1NRU3L59G7/++iuaNWv2Qsfn0kntOHk8DhvXrsJ/M66iXr36GDzCD/19Ht+c+LCoCKHBHyIt9Qzu5uXCXFULLRxaY+SYiWjl6AQASPktCXOm+Zd77K/3/gCbevVf2bVUR1w6qR3JSQmYOG50mfEB3gPx8WeLAQDR+/Zgy8avkH0jC40aN8HkqdPRvYeHxtcDwIGYn2Bbv0G5+0iayl46mXAxT2vHcm2m0tqxqhqdJAtr1qzBhx9+iJ49e2LlypXYuHEjTp06hdLSUrRr1w7Tpk1DvXqay92aMFkgOWCyQHJQ2clC4iXtJQtvNmWyoHXp6enw9/fHuXPnsH79evj4+Gjt2EwWSA6YLJAcVHaykKTFZKFjNU4WdHaDY5MmTXDkyBFERERgyJAhcHBwKPMAk99++01HsyMiIqIndLoa4sqVK9izZw8sLCzg4+PDp50REdGrVb3vS9Qanf123rBhAwIDA+Hp6YmzZ8+ibt26upoKERHJVHVfxaAtOkkW+vTpg8TERERERGDUqFG6mAIRERFJpJNkoaSkBH/88UeZJzcSERG9StX8Ix20RifJwqFDh3RxWiIiInoBvKOQiIhki4UFaZgsEBGRfDFbkESnnzpJREREVR8rC0REJFtcOikNkwUiIpItroaQhm0IIiIi0oiVBSIiki0WFqRhskBERPLFbEEStiGIiIhII1YWiIhItrgaQhpWFoiISLYUCu1tFfHzzz9jwIABsLW1hUKhQHR0tNp+QRAQEhICW1tbGBsbo3v37khNTVWLKSoqwvTp01GnTh2YmprC29sbGRkZajG5ubnw8/ODSqWCSqWCn58f7ty5U+H3ickCERHRK1ZQUIA2bdogIiKi3P1Lly7F8uXLERERgaSkJNjY2KBnz564d++eGBMQEIB9+/YhKioKx48fR35+Pry8vFBSUiLG+Pr6IiUlBTExMYiJiUFKSgr8/PwqPF+FIAhCxS+zart2u0jXUyCqdBY1jXQ9BaJKZ2pUuW2Csxn5WjuWU4OaL/Q6hUKBffv2YeDAgQAeVxVsbW0REBCAefPmAXhcRbC2tsaSJUswadIk5OXloW7duti+fTuGDRsGALh+/Trs7Oxw8OBB9O7dG2lpaXB0dMTJkyfh6uoKADh58iTc3Nzw559/omXLlpLnyMoCERHJl0J7W1FREe7evau2FRVV/I/X9PR0ZGVloVevXuKYUqmEu7s7Tpw4AQA4deoUiouL1WJsbW3h5OQkxsTHx0OlUomJAgB06tQJKpVKjJGKyQIREZEWhIWFifcGPNnCwsIqfJysrCwAgLW1tdq4tbW1uC8rKwtGRkaoXbu2xhgrK6syx7eyshJjpOJqCCIiki1troYICgrC7Nmz1caUSuULH0/x1F2TgiCUGXva0zHlxUs5ztNYWSAiItnS5moIpVIJc3Nzte1FkgUbGxsAKPPXf3Z2tlhtsLGxwcOHD5Gbm6sx5saNG2WOn5OTU6Zq8TxMFoiIiKqQJk2awMbGBocOHRLHHj58iLi4OHTu3BkA0L59exgaGqrFZGZm4uzZs2KMm5sb8vLykJiYKMYkJCQgLy9PjJGKbQgiIpItXT2SKT8/H3///bf4dXp6OlJSUmBhYYGGDRsiICAAoaGhsLe3h729PUJDQ2FiYgJfX18AgEqlgr+/PwIDA2FpaQkLCwvMmTMHzs7O8PT0BAA4ODigT58+mDBhAtavXw8AmDhxIry8vCq0EgJgskBERHKmo2whOTkZb7/9tvj1k3sdRo8ejcjISMydOxeFhYWYOnUqcnNz4erqitjYWJiZmYmvWbFiBQwMDDB06FAUFhbCw8MDkZGR0NfXF2N27NiBGTNmiKsmvL29n/lsB034nAWi1xSfs0ByUNnPWUjLLNDasRzqmWrtWFUNKwtERCRb/GwIaZgsEBGRbFX0Mx3kiqshiIiISCNWFoiISLZYWJCGyQIREckXswVJ2IYgIiIijVhZICIi2eJqCGmYLBARkWxxNYQ0bEMQERGRRqwsEBGRbLGwIA2TBSIiki9mC5KwDUFEREQasbJARESyxdUQ0jBZICIi2eJqCGnYhiAiIiKNWFkgIiLZYmFBGiYLREQkX8wWJGEbgoiIiDRiZYGIiGSLqyGkYbJARESyxdUQ0rANQURERBqxskBERLLFwoI0TBaIiEi22IaQhm0IIiIi0oiVBSIikjGWFqRgskBERLLFNoQ0bEMQERGRRqwsEBGRbLGwIA2TBSIiki22IaRhG4KIiIg0YmWBiIhki58NIQ2TBSIiki/mCpKwDUFEREQasbJARESyxcKCNEwWiIhItrgaQhq2IYiIiEgjVhaIiEi2uBpCGiYLREQkX8wVJGEbgoiIiDRiZYGIiGSLhQVpmCwQEZFscTWENGxDEBERkUasLBARkWxxNYQ0TBaIiEi22IaQhm0IIiIi0ojJAhEREWnENgQREckW2xDSsLJAREREGrGyQEREssXVENIwWSAiItliG0IatiGIiIhII1YWiIhItlhYkIbJAhERyRezBUnYhiAiIiKNWFkgIiLZ4moIaZgsEBGRbHE1hDRsQxAREZFGrCwQEZFssbAgDZMFIiKSL2YLkrANQURERBqxskBERLLF1RDSMFkgIiLZ4moIadiGICIiIo0UgiAIup4Evd6KiooQFhaGoKAgKJVKXU+HqFLw55zkjMkCvbS7d+9CpVIhLy8P5ubmup4OUaXgzznJGdsQREREpBGTBSIiItKIyQIRERFpxGSBXppSqURwcDBv+qJqjT/nJGe8wZGIiIg0YmWBiIiINGKyQERERBoxWSAiIiKNmCwQERGRRkwWSJIxY8ZAoVBg8eLFauPR0dFQ8JNY6DUmCAI8PT3Ru3fvMvvWrFkDlUqFq1ev6mBmRFUHkwWSrEaNGliyZAlyc3N1PRUirVEoFNiyZQsSEhKwfv16cTw9PR3z5s3DqlWr0LBhQx3OkEj3mCyQZJ6enrCxsUFYWNgzY/bs2YPWrVtDqVSicePG+OKLL17hDIlejJ2dHVatWoU5c+YgPT0dgiDA398fHh4eePPNN9GvXz/UrFkT1tbW8PPzw82bN8XX7t69G87OzjA2NoalpSU8PT1RUFCgw6sh0j4mCySZvr4+QkNDER4ejoyMjDL7T506haFDh2L48OE4c+YMQkJCsGDBAkRGRr76yRJV0OjRo+Hh4YGxY8ciIiICZ8+exapVq+Du7o62bdsiOTkZMTExuHHjBoYOHQoAyMzMxIgRIzBu3DikpaXh2LFjGDRoEPj4Gqpu+FAmkmTMmDG4c+cOoqOj4ebmBkdHR2zatAnR0dF45513IAgCRo4ciZycHMTGxoqvmzt3Lr7//nukpqbqcPZE0mRnZ8PJyQm3bt3C7t27cfr0aSQkJODHH38UYzIyMmBnZ4fz588jPz8f7du3x+XLl9GoUSMdzpyocrGyQBW2ZMkSbN26FefOnVMbT0tLQ5cuXdTGunTpggsXLqCkpORVTpHohVhZWWHixIlwcHDAO++8g1OnTuHo0aOoWbOmuLVq1QoAcPHiRbRp0wYeHh5wdnbGu+++iw0bNvCeHqqWmCxQhXXr1g29e/fG/Pnz1cYFQSizMoKFK3rdGBgYwMDAAABQWlqKAQMGICUlRW27cOECunXrBn19fRw6dAg//PADHB0dER4ejpYtWyI9PV3HV0GkXQa6ngC9nhYvXoy2bduiRYsW4pijoyOOHz+uFnfixAm0aNEC+vr6r3qKRC+tXbt22LNnDxo3biwmEE9TKBTo0qULunTpgoULF6JRo0bYt28fZs+e/YpnS1R5WFmgF+Ls7IyRI0ciPDxcHAsMDMThw4exaNEi/PXXX9i6dSsiIiIwZ84cHc6U6MVNmzYNt2/fxogRI5CYmIhLly4hNjYW48aNQ0lJCRISEhAaGork5GRcvXoVe/fuRU5ODhwcHHQ9dSKtYrJAL2zRokVqbYZ27dph165diIqKgpOTExYuXIhPPvkEY8aM0d0kiV6Cra0tfv31V5SUlKB3795wcnLCzJkzoVKpoKenB3Nzc/z888/o168fWrRogX/961/44osv0LdvX11PnUiruBqCiIiINGJlgYiIiDRiskBEREQaMVkgIiIijZgsEBERkUZMFoiIiEgjJgtERESkEZMFIiIi0ojJAhEREWnEZIHoNRASEoK2bduKX48ZMwYDBw585fO4fPkyFAoFUlJSXvm5iUh3mCwQvYQxY8ZAoVBAoVDA0NAQTZs2xZw5c1BQUFCp5121ahUiIyMlxfIXPBG9LH7qJNFL6tOnD7Zs2YLi4mL88ssvGD9+PAoKCrB27Vq1uOLiYhgaGmrlnCqVSivHISKSgpUFopekVCphY2MDOzs7+Pr6YuTIkYiOjhZbB5s3b0bTpk2hVCohCALy8vIwceJEWFlZwdzcHD169MDvv/+udszFixfD2toaZmZm8Pf3x4MHD9T2P92GKC0txZIlS9C8eXMolUo0bNgQn332GQCgSZMmAAAXFxcoFAp0795dfN2WLVvg4OCAGjVqoFWrVlizZo3aeRITE+Hi4oIaNWqgQ4cOOH36tBbfOSJ6XbCyQKRlxsbGKC4uBgD8/fff2LVrF/bs2QN9fX0AQP/+/WFhYYGDBw9CpVJh/fr18PDwwF9//QULCwvs2rULwcHB+PLLL9G1a1ds374dq1evRtOmTZ95zqCgIGzYsAErVqzAW2+9hczMTPz5558AHv/Cf/PNN/HTTz+hdevWMDIyAgBs2LABwcHBiIiIgIuLC06fPo0JEybA1NQUo0ePRkFBAby8vNCjRw98/fXXSE9Px8yZMyv53SOiKkkgohc2evRowcfHR/w6ISFBsLS0FIYOHSoEBwcLhoaGQnZ2trj/8OHDgrm5ufDgwQO14zRr1kxYv369IAiC4ObmJkyePFltv6urq9CmTZtyz3v37l1BqVQKGzZsKHeO6enpAgDh9OnTauN2dnbCzp071cYWLVokuLm5CYIgCOvXrxcsLCyEgoICcf/atWvLPRYRVW9sQxC9pAMHDqBmzZqoUaMG3Nzc0K1bN4SHhwMAGjVqhLp164qxp06dQn5+PiwtLVGzZk1xS09Px8WLFwEAaWlpcHNzUzvH01//U1paGoqKiuDh4SF5zjk5Obh27Rr8/f3V5vHpp5+qzaNNmzYwMTGRNA8iqr7YhiB6SW+//TbWrl0LQ0ND2Nraqt3EaGpqqhZbWlqKevXq4dixY2WOU6tWrRc6v7GxcYVfU1paCuBxK8LV1VVt35N2iSAILzQfIqp+mCwQvSRTU1M0b95cUmy7du2QlZUFAwMDNG7cuNwYBwcHnDx5EqNGjRLHTp48+cxj2tvbw9jYGIcPH8b48ePL7H9yj0JJSYk4Zm1tjfr16+PSpUsYOXJkucd1dHTE9u3bUVhYKCYkmuZBRNUX2xBEr5Cnpyfc3NwwcOBA/Pjjj7h8+TJOnDiBf/3rX0hOTgYAzJw5E5s3b8bmzZvx119/ITg4GKmpqc88Zo0aNTBv3jzMnTsX27Ztw8WLF3Hy5Els2rQJAGBlZQVjY2PExMTgxo0byMvLA/D4QU9hYWFYtWoV/vrrL5w5cwZbtmzB8uXLAQC+vr7Q09ODv78/zp07h4MHD+Lzzz+v5HeIiKoiJgtEr5BCocDBgwfRrVs3jBs3Di1atMDw4cNx+fJlWFtbAwCGDRuGhQsXYt68eWjfvj2uXLmCKVOmaDzuggULEBgYiIULF8LBwQHDhg1DdnY2AMDAwACrV6/G+vXrYWtrCx8fHwDA+PHjsXHjRkRGRsLZ2Rnu7u6IjIwUl1rWrFkT+/fvx7lz5+Di4oKPPvoIS5YsqcR3h4iqKoXAxiQRERFpwMoCERERacRkgYiIiDRiskBEREQaMVkgIiIijZgsEBERkUZMFoiIiEgjJgtERESkEZMFIiIi0ojJAhEREWnEZIGIiIg0YrJAREREGv0fHXRZ3RZdR4gAAAAASUVORK5CYII=", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "# Set a seed for reproducibility\n", - "np.random.seed(42)\n", - "\n", - "# Assuming bank_data is already loaded\n", - "unknown_columns = bank_data.columns[bank_data.isin(['unknown']).any()]\n", - "\n", - "# Clean the data by removing rows with 'unknown' values\n", - "cleaned_data = bank_data[~bank_data.isin(['unknown']).any(axis=1)]\n", - "\n", - "# Define feature subsets\n", - "numeric_feats = ['age', 'emp.var.rate', 'cons.price.idx', 'cons.conf.idx', 'euribor3m', 'nr.employed', 'campaign']\n", - "categorical_feats = ['job', 'education', 'default', 'housing', 'loan', 'contact', 'poutcome']\n", - "drop_feats = ['duration', 'month', 'day_of_week', 'pdays', 'marital', 'previous']\n", - "\n", - "# Separate features and target variable\n", - "X = cleaned_data.drop(columns=drop_feats + ['y']) # Features excluding target 'y' and drop_feats\n", - "y = cleaned_data['y'] # Target variable\n", - "\n", - "# Create the column transformer to apply preprocessing\n", - "ct = make_column_transformer(\n", - " (StandardScaler(), numeric_feats), # Standard scaling for numeric features\n", - " (OneHotEncoder(drop=\"if_binary\", sparse_output=False), categorical_feats) # One-hot encoding for categorical features\n", - ")\n", - "\n", - "# Create a pipeline with preprocessing and logistic regression model\n", - "pipeline = Pipeline(steps=[\n", - " ('preprocessor', ct),\n", - " ('classifier', LogisticRegression(solver='liblinear')) # Using 'liblinear' solver for small datasets\n", - "])\n", - "\n", - "# Define the hyperparameter grid\n", - "param_grid = {\n", - " 'classifier__C': [0.01, 0.1, 1, 10, 100], # Regularization strength\n", - " 'classifier__penalty': ['l1', 'l2'], # Regularization type\n", - " 'classifier__solver': ['liblinear'], # Solver for logistic regression\n", - " 'classifier__max_iter': [100, 200, 300] # Maximum number of iterations for convergence\n", - "}\n", - "\n", - "# Create GridSearchCV with cross-validation\n", - "grid_search = GridSearchCV(pipeline, param_grid, cv=5, scoring='accuracy', n_jobs=-1)\n", - "\n", - "# Split the data into training and testing sets\n", - "X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)\n", - "\n", - "# Fit the grid search to the data\n", - "grid_search.fit(X_train, y_train)\n", - "\n", - "# Print the best parameters found by GridSearchCV\n", - "print(\"Best hyperparameters found: \", grid_search.best_params_)\n", - "\n", - "# Make predictions with the best model\n", - "y_pred = grid_search.predict(X_test)\n", - "\n", - "# Evaluate the model\n", - "accuracy = accuracy_score(y_test, y_pred)\n", - "conf_matrix = confusion_matrix(y_test, y_pred)\n", - "\n", - "# Print evaluation metrics\n", - "print(\"Accuracy:\", accuracy)\n", - "print(\"Confusion Matrix:\\n\", conf_matrix)\n", - "\n", - "# Additional evaluation metrics\n", - "# Additional evaluation metrics\n", - "precision = precision_score(y_test, y_pred, pos_label='yes') # Specify pos_label\n", - "recall = recall_score(y_test, y_pred, pos_label='yes')\n", - "f1 = f1_score(y_test, y_pred, pos_label='yes')\n", - "# Print additional metrics\n", - "print(\"Logistic Regression Evaluation:\")\n", - "print(f\"Accuracy: {accuracy:.2f}\")\n", - "print(f\"Precision: {precision:.2f}\")\n", - "print(f\"Recall: {recall:.2f}\")\n", - "print(f\"F1 Score: {f1:.2f}\")\n", - "\n", - "\n", - "# Plot confusion matrix heatmap\n", - "plt.figure(figsize=(6, 5))\n", - "sns.heatmap(conf_matrix, annot=True, fmt=\"d\", cmap=\"Blues\", xticklabels=['No', 'Yes'], yticklabels=['No', 'Yes'])\n", - "plt.title('Confusion Matrix Heatmap')\n", - "plt.xlabel('Predicted')\n", - "plt.ylabel('Actual')\n", - "plt.show()\n" - ] - }, - { - "cell_type": "code", - "execution_count": 17, - "id": "6e32d3c8-32ca-4221-ba72-14db121f32a9", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Fitting 5 folds for each of 90 candidates, totalling 450 fits\n", - "Best Parameters from Grid Search: {'classifier__criterion': 'entropy', 'classifier__max_depth': 5, 'classifier__min_samples_leaf': 1, 'classifier__min_samples_split': 2}\n", - "Accuracy: 0.8973051711580481\n", - "Confusion Matrix:\n", - " [[7177 126]\n", - " [ 720 215]]\n", - "Decision Tree Evaluation with Optimized Hyperparameters:\n", - "Accuracy: 0.90\n", - "Precision: 0.63\n", - "Recall: 0.23\n", - "F1 Score: 0.34\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "# Set a seed for reproducibility\n", - "np.random.seed(42)\n", - "\n", - "# Assuming bank_data is already loaded\n", - "unknown_columns = bank_data.columns[bank_data.isin(['unknown']).any()]\n", - "\n", - "# Clean the data by replacing 'unknown' values with a placeholder (e.g., 'other')\n", - "cleaned_data = bank_data.apply(lambda col: col.replace('unknown', 'other') if col.dtypes == 'object' else col)\n", - "\n", - "# Define feature subsets\n", - "numeric_feats = ['age', 'emp.var.rate', 'cons.price.idx', 'cons.conf.idx', 'euribor3m', 'nr.employed', 'campaign']\n", - "categorical_feats = ['job', 'education', 'default', 'housing', 'loan', 'contact', 'poutcome']\n", - "drop_feats = ['duration', 'month', 'day_of_week', 'pdays', 'marital', 'previous']\n", - "\n", - "# Separate features and target variable\n", - "X = cleaned_data.drop(columns=drop_feats + ['y']) # Features excluding target 'y' and drop_feats\n", - "y = cleaned_data['y'] # Target variable\n", - "\n", - "# Create the column transformer to apply preprocessing\n", - "ct = make_column_transformer(\n", - " (StandardScaler(), numeric_feats), # Standard scaling for numeric features\n", - " (OneHotEncoder(drop=\"if_binary\", sparse_output=False), categorical_feats) # One-hot encoding for categorical features\n", - ")\n", - "\n", - "# Create a pipeline with preprocessing and decision tree classifier\n", - "pipeline = Pipeline(steps=[\n", - " ('preprocessor', ct),\n", - " ('classifier', DecisionTreeClassifier(random_state=42)) # Decision tree model\n", - "])\n", - "\n", - "# Define parameter grid for grid search\n", - "param_grid = {\n", - " 'classifier__max_depth': [3, 5, 7, 10, None], # Maximum depth of tree\n", - " 'classifier__min_samples_split': [2, 5, 10], # Minimum samples to split a node\n", - " 'classifier__min_samples_leaf': [1, 2, 5], # Minimum samples required to be a leaf node\n", - " 'classifier__criterion': ['gini', 'entropy'] # Criterion for splitting nodes\n", - "}\n", - "\n", - "# Create a GridSearchCV object\n", - "grid_search = GridSearchCV(pipeline, param_grid, cv=5, n_jobs=-1, verbose=1)\n", - "\n", - "# Split the data into training and testing sets\n", - "X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)\n", - "\n", - "# Fit the grid search to the data\n", - "grid_search.fit(X_train, y_train)\n", - "\n", - "# Best model from grid search\n", - "best_model = grid_search.best_estimator_\n", - "\n", - "# Make predictions using the best model\n", - "y_pred = best_model.predict(X_test)\n", - "\n", - "# Evaluate the model\n", - "accuracy = accuracy_score(y_test, y_pred)\n", - "conf_matrix = confusion_matrix(y_test, y_pred)\n", - "\n", - "# Print evaluation metrics\n", - "print(\"Best Parameters from Grid Search:\", grid_search.best_params_)\n", - "print(\"Accuracy:\", accuracy)\n", - "print(\"Confusion Matrix:\\n\", conf_matrix)\n", - "\n", - "# Additional evaluation metrics\n", - "precision = precision_score(y_test, y_pred, pos_label='yes') # Specify pos_label\n", - "recall = recall_score(y_test, y_pred, pos_label='yes')\n", - "f1 = f1_score(y_test, y_pred, pos_label='yes')\n", - "\n", - "# Print additional metrics\n", - "print(\"Decision Tree Evaluation with Optimized Hyperparameters:\")\n", - "print(f\"Accuracy: {accuracy:.2f}\")\n", - "print(f\"Precision: {precision:.2f}\")\n", - "print(f\"Recall: {recall:.2f}\")\n", - "print(f\"F1 Score: {f1:.2f}\")\n", - "\n", - "# Plot confusion matrix heatmap\n", - "plt.figure(figsize=(6, 5))\n", - "sns.heatmap(conf_matrix, annot=True, fmt=\"d\", cmap=\"Blues\", xticklabels=['No', 'Yes'], yticklabels=['No', 'Yes'])\n", - "plt.title('Confusion Matrix Heatmap')\n", - "plt.xlabel('Predicted')\n", - "plt.ylabel('Actual')\n", - "plt.show()\n", - "\n", - "# Extract feature names after one-hot encoding\n", - "ohe = best_model.named_steps['preprocessor'].transformers_[1][1] # Get the OneHotEncoder\n", - "ohe_columns = ohe.get_feature_names_out(categorical_feats)\n", - "\n", - "# Combine numeric and categorical features\n", - "feature_names = numeric_feats + list(ohe_columns)\n", - "\n" - ] - }, - { - "cell_type": "code", - "execution_count": 18, - "id": "0f392550-cb70-4899-a41d-9e9cdd28872c", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "# Get the decision tree model after optimization\n", - "best_tree = best_model.named_steps['classifier']\n", - "\n", - "# Get the feature names after one-hot encoding\n", - "ohe = best_model.named_steps['preprocessor'].transformers_[1][1] # Get the OneHotEncoder\n", - "ohe_columns = ohe.get_feature_names_out(categorical_feats)\n", - "\n", - "# Combine the numeric and one-hot encoded feature names\n", - "feature_names = numeric_feats + list(ohe_columns)\n", - "\n", - "# Set a higher DPI (dots per inch) for better quality and save the figure\n", - "plt.figure(figsize=(20, 15)) # Increase the size for better visibility\n", - "plot_tree(best_tree, filled=True, feature_names=feature_names, class_names=['no', 'yes'], rounded=True, max_depth=5)\n", - "\n", - "# Save the plot as a high-resolution image\n", - "plt.title('Optimized Decision Tree Visualization (Limited Depth)')\n", - "plt.savefig('decision_tree_high_res.png', dpi=300) # Save with 300 dpi for high resolution\n", - "plt.show()" - ] - }, - { - "cell_type": "markdown", - "id": "85f9b7f2-7e06-4078-894f-8727f70c8e4a", - "metadata": {}, - "source": [ - "# Discussion\n", - "\n", - "## Logistic Regression Model:\n", - "\n", - "The Logistic Regression model has achieved an accuracy of approximately 88.5%, with the best hyperparameters found as: \n", - "`{'classifier__C': 0.1, 'classifier__max_iter': 100, 'classifier__penalty': 'l1', 'classifier__solver': 'liblinear'}`. The confusion matrix for this model is as follows:\n", - "\n", - "- **True Negatives (5236)**: The model correctly identified 5236 non-subscribers, which indicates its strong performance in predicting the majority class (non-subscribers).\n", - "- **False Positives (68)**: There are 68 instances where the model incorrectly predicted that non-subscribers would subscribe. This is a relatively low number, indicating that the model is relatively efficient at avoiding unnecessary targeting.\n", - "- **False Negatives (632)**: The model missed 632 actual subscribers, which is a significant number and highlights the low recall.\n", - "- **True Positives (162)**: The model correctly predicted 162 subscribers, but this number is still quite low, reflecting the model's struggle to identify potential subscribers.\n", - "\n", - "The **Precision** is 0.70, meaning that 70% of the customers predicted as subscribers are actually subscribers. However, the **Recall** is only 0.20, meaning the model captures just 20% of the actual subscribers, which is quite low. This results in an **F1 Score** of 0.32, reflecting a poor balance between precision and recall. Despite the good precision, the low recall suggests that the model is not effectively identifying many actual subscribers, pointing to a significant trade-off between false positives and false negatives. This version of Logistic Regression is more suited to scenarios where **precision** (minimizing false positives) is prioritized over **recall** (capturing all potential subscribers).\n", - "\n", - "## Decision Tree Model:\n", - "\n", - "After performing a grid search for hyperparameter optimization, the best hyperparameters found are: \n", - "`{'classifier__criterion': 'entropy', 'classifier__max_depth': 5, 'classifier__min_samples_leaf': 1, 'classifier__min_samples_split': 2}`. The model achieved an accuracy of approximately 89.7%, with the confusion matrix as follows:\n", - "\n", - "- **True Negatives (7177)**: The Decision Tree correctly predicted 7177 non-subscribers, showing solid performance in predicting the majority class (non-subscribers).\n", - "- **False Positives (126)**: There are 126 instances where the model incorrectly predicted non-subscribers as subscribers, which is a moderate number compared to the Logistic Regression model, indicating a higher sensitivity to identifying potential subscribers.\n", - "- **False Negatives (720)**: The model failed to predict 720 actual subscribers, a somewhat higher number, reflecting a lower recall than might be ideal.\n", - "- **True Positives (215)**: The Decision Tree correctly predicted 215 subscribers, which is an improvement over the Logistic Regression model, suggesting it is better at identifying potential subscribers.\n", - "\n", - "The **Precision** is 0.63, meaning 63% of the customers predicted as subscribers are indeed subscribers. The **Recall** is 0.23, meaning the model captures only 23% of actual subscribers, indicating it still misses a significant portion. This results in an **F1 Score** of 0.34, which is slightly higher than the Logistic Regression model but still reflects an imbalance between precision and recall. The Decision Tree model performs better than Logistic Regression in terms of recall but still struggles to capture a large proportion of the potential subscribers. It might benefit from further adjustments, such as pruning, to reduce the number of false positives and improve its recall.\n", - "\n", - "Although the Decision Tree has a slightly lower accuracy, its **higher recall** (more true positives) suggests it is better at identifying potential subscribers. However, its higher **false positives** indicate that the model might be overfitting, capturing noise in the data. This suggests that the Decision Tree is more sensitive to patterns in the data but might benefit from **regularization** or **pruning** to reduce overfitting.\n", - "\n", - "## Comparison and Implications:\n", - "\n", - "\n", - "Both models indicate that the most common outcome in the dataset is non-subscription, as reflected in the confusion matrices, where the number of true negatives vastly outweighs the number of true positives. This confirms that \"no\" is the statistically likely outcome for customer subscription.\n", - "\n", - "- **Logistic Regression Model**: The Logistic Regression model is better suited for situations where minimizing false positives is critical, as its **precision** (0.70) is higher than that of the Decision Tree model. However, its **recall** (0.20) is lower, meaning it misses a significant portion of actual subscribers. This makes the Logistic Regression model more effective in contexts where avoiding unnecessary targeting of non-subscribers is more important than capturing every potential subscriber.\n", - "\n", - "- **Decision Tree Model**: The Decision Tree model, while slightly less accurate overall (**accuracy = 89.7%**), has a better **recall** (0.23), meaning it identifies more true positives compared to Logistic Regression. However, this comes at the cost of an increased number of **false positives** (126). As such, the Decision Tree is better at capturing potential subscribers but may lead to more resources being spent on non-converting customers.\n", - "\n", - "### Implications:\n", - "Both models show reasonable accuracy and can be useful for the business’s marketing initiatives to increase term deposits (subscriptions). The Logistic Regression model would be advantageous in scenarios where reducing false positives and minimizing resource expenditure is a priority, while the Decision Tree model could be valuable in situations where capturing more potential subscribers (even at the cost of more false positives). \n", - "\n", - "Future iterations of these models should focus on improving both **precision** and **recall**, possibly through regularization, pruning, or incorporating more diverse data to better identify customers likely to subscribe. By fine-tuning the models, the business can maximize the effectiveness of its marketing campaigns and increase its return on investment.\n", - "\n", - "\n", - "## Strategic Recommendations:\n", - "Given the insights from the evaluation of both models, here are some actionable strategies to enhance the bank's marketing efforts and improve conversion rates:\n", - "\n", - "### Targeted Marketing:\n", - "- Use these models to segment customers into two groups: those with a high likelihood of subscribing (identified by the model as potential positives) and those with a low likelihood (predicted as negatives). Focus marketing efforts on the high-probability segment to optimize resource allocation.\n", - "\n", - "### Campaign Timing:\n", - "- Refine marketing strategies by focusing efforts on customers during certain times when they are more likely to respond. The model can be expanded to include temporal features (e.g., day of the week or month) to optimize campaign timing.\n", - "\n", - "### Personalized Offers:\n", - "- Tailor offers to individual customers based on characteristics like age, occupation, or previous interactions with the bank (e.g., loan status). The models' predictions can guide personalized messaging, increasing engagement with customers and improving the chances of subscription.\n", - "\n", - "### Improve Conversion Rates:\n", - "- Implement **follow-up campaigns** targeting customers predicted as high-likelihood subscribers but who still did not convert. For those predicted as low-likelihood, consider creating new or improved offers to address specific concerns or barriers to subscription.\n", - "\n", - "### Monitor and Adjust:\n", - "- Continuously track the performance of both models over time, paying close attention to precision and recall. As more data becomes available, adjust the models and marketing strategies to ensure increasing accuracy and the development of more effective campaigns.\n", - "\n", - "By applying these insights and strategies, the bank can improve its targeting for **long-term deposit** products, increasing conversion rates while making sure the marketing efforts are cost-effective and personalized.\n", - "\n", - "--For the markdown rendering Chat-gpt was used to correct code" - ] - }, - { - "cell_type": "markdown", - "id": "03f4953e-41d9-4608-9179-71ab7ecf9a73", - "metadata": {}, - "source": [ - "# References" - ] - }, - { - "cell_type": "markdown", - "id": "108ebaae-b1cc-4bb6-82d2-10c274f3b96a", - "metadata": {}, - "source": [ - "Meshref, H. (2020). Predicting loan approval of bank direct marketing data using ensemble machine learning algorithms. International Journal of Circuits, Systems and Signal Processing, 14, 117. https://doi.org/10.46300/9106.2020.14.117\n", - "\n", - "Moro, S., Rita, P., & Cortez, P. (2014). Bank Marketing [Dataset]. UCI Machine Learning Repository. https://doi.org/10.24432/C5K306\n", - "\n", - "Wang, D. (2020). Research on bank marketing behavior based on machine learning. AIAM2020: Proceedings of the 2nd International Conference on Artificial Intelligence and Advanced Manufacture, 150–154. https://doi.org/10.1145/3421766.3421800\n", - "\n", - "Xie, C., Zhang, J.-L., Zhu, Y., Xiong, B., & Wang, G.-J. (2023). How to improve the success of bank telemarketing? Prediction and interpretability analysis based on machine learning. Computers & Industrial Engineering, 175, 108874. https://doi.org/10.1016/j.cie.2022.108874\n", - "\n", - "Zaki, A. M., Khodadadi, N., Lim, W. H., & Towfek, S. K. (2024). Predictive analytics and machine learning in direct marketing for anticipating bank term deposit subscriptions. American Journal of Business and Operations Research, 11(1), 79-88. https://doi.org/10.54216/AJBOR.110110" - ] - } - ], - "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.9" - } - }, - "nbformat": 4, - "nbformat_minor": 5 -} diff --git a/.ipynb_checkpoints/conda-linux-64-checkpoint.lock b/.ipynb_checkpoints/conda-linux-64-checkpoint.lock deleted file mode 100644 index 2c28c76..0000000 --- a/.ipynb_checkpoints/conda-linux-64-checkpoint.lock +++ /dev/null @@ -1,227 +0,0 @@ -# Generated by conda-lock. -# platform: linux-64 -# input_hash: 02d448e4d12567c900f75e09196c1e2165e8e8fa981e6e38d474eaedddc7bf9a -@EXPLICIT -https://conda.anaconda.org/conda-forge/linux-64/_libgcc_mutex-0.1-conda_forge.tar.bz2#d7c89558ba9fa0495403155b64376d81 -https://conda.anaconda.org/conda-forge/linux-64/ca-certificates-2024.8.30-hbcca054_0.conda#c27d1c142233b5bc9ca570c6e2e0c244 -https://conda.anaconda.org/conda-forge/noarch/font-ttf-dejavu-sans-mono-2.37-hab24e00_0.tar.bz2#0c96522c6bdaed4b1566d11387caaf45 -https://conda.anaconda.org/conda-forge/noarch/font-ttf-inconsolata-3.000-h77eed37_0.tar.bz2#34893075a5c9e55cdafac56607368fc6 -https://conda.anaconda.org/conda-forge/noarch/font-ttf-source-code-pro-2.038-h77eed37_0.tar.bz2#4d59c254e01d9cde7957100457e2d5fb -https://conda.anaconda.org/conda-forge/noarch/font-ttf-ubuntu-0.83-h77eed37_3.conda#49023d73832ef61042f6a237cb2687e7 -https://conda.anaconda.org/conda-forge/linux-64/python_abi-3.11-5_cp311.conda#139a8d40c8a2f430df31048949e450de -https://conda.anaconda.org/conda-forge/noarch/tzdata-2024b-hc8b5060_0.conda#8ac3367aafb1cc0a068483c580af8015 -https://conda.anaconda.org/conda-forge/noarch/fonts-conda-forge-1-0.tar.bz2#f766549260d6815b0c52253f1fb1bb29 -https://conda.anaconda.org/conda-forge/linux-64/ld_impl_linux-64-2.43-h712a8e2_2.conda#048b02e3962f066da18efe3a21b77672 -https://conda.anaconda.org/conda-forge/linux-64/libglvnd-1.7.0-ha4b6fd6_2.conda#434ca7e50e40f4918ab701e3facd59a0 -https://conda.anaconda.org/conda-forge/linux-64/libgomp-14.2.0-h77fa898_1.conda#cc3573974587f12dda90d96e3e55a702 -https://conda.anaconda.org/conda-forge/linux-64/_openmp_mutex-4.5-2_gnu.tar.bz2#73aaf86a425cc6e73fcf236a5a46396d -https://conda.anaconda.org/conda-forge/noarch/fonts-conda-ecosystem-1-0.tar.bz2#fee5683a3f04bd15cbd8318b096a27ab -https://conda.anaconda.org/conda-forge/linux-64/libegl-1.7.0-ha4b6fd6_2.conda#c151d5eb730e9b7480e6d48c0fc44048 -https://conda.anaconda.org/conda-forge/linux-64/libopengl-1.7.0-ha4b6fd6_2.conda#7df50d44d4a14d6c31a2c54f2cd92157 -https://conda.anaconda.org/conda-forge/linux-64/libgcc-14.2.0-h77fa898_1.conda#3cb76c3f10d3bc7f1105b2fc9db984df -https://conda.anaconda.org/conda-forge/linux-64/alsa-lib-1.2.13-hb9d3cd8_0.conda#ae1370588aa6a5157c34c73e9bbb36a0 -https://conda.anaconda.org/conda-forge/linux-64/aws-c-common-0.10.3-hb9d3cd8_0.conda#ff3653946d34a6a6ba10babb139d96ef -https://conda.anaconda.org/conda-forge/linux-64/c-ares-1.34.3-hb9d3cd8_1.conda#ee228789a85f961d14567252a03e725f -https://conda.anaconda.org/conda-forge/linux-64/libbrotlicommon-1.1.0-hb9d3cd8_2.conda#41b599ed2b02abcfdd84302bff174b23 -https://conda.anaconda.org/conda-forge/linux-64/libdeflate-1.22-hb9d3cd8_0.conda#b422943d5d772b7cc858b36ad2a92db5 -https://conda.anaconda.org/conda-forge/linux-64/libexpat-2.6.4-h5888daf_0.conda#db833e03127376d461e1e13e76f09b6c -https://conda.anaconda.org/conda-forge/linux-64/libgcc-ng-14.2.0-h69a702a_1.conda#e39480b9ca41323497b05492a63bc35b -https://conda.anaconda.org/conda-forge/linux-64/libgfortran5-14.2.0-hd5240d6_1.conda#9822b874ea29af082e5d36098d25427d -https://conda.anaconda.org/conda-forge/linux-64/libstdcxx-14.2.0-hc0a3c3a_1.conda#234a5554c53625688d51062645337328 -https://conda.anaconda.org/conda-forge/linux-64/libzlib-1.3.1-hb9d3cd8_2.conda#edb0dca6bc32e4f4789199455a1dbeb8 -https://conda.anaconda.org/conda-forge/linux-64/openssl-3.4.0-hb9d3cd8_0.conda#23cc74f77eb99315c0360ec3533147a9 -https://conda.anaconda.org/conda-forge/linux-64/pthread-stubs-0.4-hb9d3cd8_1002.conda#b3c17d95b5a10c6e64a21fa17573e70e -https://conda.anaconda.org/conda-forge/linux-64/xorg-libice-1.1.1-hb9d3cd8_1.conda#19608a9656912805b2b9a2f6bd257b04 -https://conda.anaconda.org/conda-forge/linux-64/xorg-libxau-1.0.11-hb9d3cd8_1.conda#77cbc488235ebbaab2b6e912d3934bae -https://conda.anaconda.org/conda-forge/linux-64/xorg-libxdmcp-1.1.5-hb9d3cd8_0.conda#8035c64cb77ed555e3f150b7b3972480 -https://conda.anaconda.org/conda-forge/linux-64/xorg-xorgproto-2024.1-hb9d3cd8_1.conda#7c21106b851ec72c037b162c216d8f05 -https://conda.anaconda.org/conda-forge/linux-64/aws-c-cal-0.8.0-hecf86a2_2.conda#c54459d686ad9d0502823cacff7e8423 -https://conda.anaconda.org/conda-forge/linux-64/aws-c-compression-0.3.0-hf42f96a_2.conda#257f4ae92fe11bd8436315c86468c39b -https://conda.anaconda.org/conda-forge/linux-64/aws-c-sdkutils-0.2.1-hf42f96a_1.conda#bbdd20fb1994a9f0ba98078fcb6c12ab -https://conda.anaconda.org/conda-forge/linux-64/aws-checksums-0.2.2-hf42f96a_1.conda#d908d43d87429be24edfb20e96543c20 -https://conda.anaconda.org/conda-forge/linux-64/bzip2-1.0.8-h4bc722e_7.conda#62ee74e96c5ebb0af99386de58cf9553 -https://conda.anaconda.org/conda-forge/linux-64/expat-2.6.4-h5888daf_0.conda#1d6afef758879ef5ee78127eb4cd2c4a -https://conda.anaconda.org/conda-forge/linux-64/gflags-2.2.2-h5888daf_1005.conda#d411fc29e338efb48c5fd4576d71d881 -https://conda.anaconda.org/conda-forge/linux-64/keyutils-1.6.1-h166bdaf_0.tar.bz2#30186d27e2c9fa62b45fb1476b7200e3 -https://conda.anaconda.org/conda-forge/linux-64/libabseil-20240722.0-cxx17_h5888daf_1.conda#e1f604644fe8d78e22660e2fec6756bc -https://conda.anaconda.org/conda-forge/linux-64/libbrotlidec-1.1.0-hb9d3cd8_2.conda#9566f0bd264fbd463002e759b8a82401 -https://conda.anaconda.org/conda-forge/linux-64/libbrotlienc-1.1.0-hb9d3cd8_2.conda#06f70867945ea6a84d35836af780f1de -https://conda.anaconda.org/conda-forge/linux-64/libev-4.33-hd590300_2.conda#172bf1cd1ff8629f2b1179945ed45055 -https://conda.anaconda.org/conda-forge/linux-64/libevent-2.1.12-hf998b51_1.conda#a1cfcc585f0c42bf8d5546bb1dfb668d -https://conda.anaconda.org/conda-forge/linux-64/libffi-3.4.2-h7f98852_5.tar.bz2#d645c6d2ac96843a2bfaccd2d62b3ac3 -https://conda.anaconda.org/conda-forge/linux-64/libgfortran-14.2.0-h69a702a_1.conda#f1fd30127802683586f768875127a987 -https://conda.anaconda.org/conda-forge/linux-64/libiconv-1.17-hd590300_2.conda#d66573916ffcf376178462f1b61c941e -https://conda.anaconda.org/conda-forge/linux-64/libjpeg-turbo-3.0.0-hd590300_1.conda#ea25936bb4080d843790b586850f82b8 -https://conda.anaconda.org/conda-forge/linux-64/libnsl-2.0.1-hd590300_0.conda#30fd6e37fe21f86f4bd26d6ee73eeec7 -https://conda.anaconda.org/conda-forge/linux-64/libntlm-1.4-h7f98852_1002.tar.bz2#e728e874159b042d92b90238a3cb0dc2 -https://conda.anaconda.org/conda-forge/linux-64/libpciaccess-0.18-hd590300_0.conda#48f4330bfcd959c3cfb704d424903c82 -https://conda.anaconda.org/conda-forge/linux-64/libpng-1.6.44-hadc24fc_0.conda#f4cc49d7aa68316213e4b12be35308d1 -https://conda.anaconda.org/conda-forge/linux-64/libsqlite-3.47.0-hadc24fc_1.conda#b6f02b52a174e612e89548f4663ce56a -https://conda.anaconda.org/conda-forge/linux-64/libssh2-1.11.1-hf672d98_0.conda#be2de152d8073ef1c01b7728475f2fe7 -https://conda.anaconda.org/conda-forge/linux-64/libstdcxx-ng-14.2.0-h4852527_1.conda#8371ac6457591af2cf6159439c1fd051 -https://conda.anaconda.org/conda-forge/linux-64/libutf8proc-2.8.0-h166bdaf_0.tar.bz2#ede4266dc02e875fe1ea77b25dd43747 -https://conda.anaconda.org/conda-forge/linux-64/libuuid-2.38.1-h0b41bf4_0.conda#40b61aab5c7ba9ff276c41cfffe6b80b -https://conda.anaconda.org/conda-forge/linux-64/libwebp-base-1.4.0-hd590300_0.conda#b26e8aa824079e1be0294e7152ca4559 -https://conda.anaconda.org/conda-forge/linux-64/libxcb-1.17.0-h8a09558_0.conda#92ed62436b625154323d40d5f2f11dd7 -https://conda.anaconda.org/conda-forge/linux-64/libxcrypt-4.4.36-hd590300_1.conda#5aa797f8787fe7a17d1b0821485b5adc -https://conda.anaconda.org/conda-forge/linux-64/mysql-common-9.0.1-h266115a_2.conda#85c0dc0bcd110c998b01856975486ee7 -https://conda.anaconda.org/conda-forge/linux-64/ncurses-6.5-he02047a_1.conda#70caf8bb6cf39a0b6b7efc885f51c0fe -https://conda.anaconda.org/conda-forge/linux-64/s2n-1.5.9-h0fd0ee4_0.conda#f472432f3753c5ca763d2497e2ea30bf -https://conda.anaconda.org/conda-forge/linux-64/tk-8.6.13-noxft_h4845f30_101.conda#d453b98d9c83e71da0741bb0ff4d76bc -https://conda.anaconda.org/conda-forge/linux-64/xz-5.2.6-h166bdaf_0.tar.bz2#2161070d867d1b1204ea749c8eec4ef0 -https://conda.anaconda.org/conda-forge/linux-64/zlib-1.3.1-hb9d3cd8_2.conda#c9f075ab2f33b3bbee9e62d4ad0a6cd8 -https://conda.anaconda.org/conda-forge/linux-64/aws-c-io-0.15.2-hdeadb07_2.conda#461a1eaa075fd391add91bcffc9de0c1 -https://conda.anaconda.org/conda-forge/linux-64/brotli-bin-1.1.0-hb9d3cd8_2.conda#c63b5e52939e795ba8d26e35d767a843 -https://conda.anaconda.org/conda-forge/linux-64/double-conversion-3.3.0-h59595ed_0.conda#c2f83a5ddadadcdb08fe05863295ee97 -https://conda.anaconda.org/conda-forge/linux-64/freetype-2.12.1-h267a509_2.conda#9ae35c3d96db2c94ce0cef86efdfa2cb -https://conda.anaconda.org/conda-forge/linux-64/glog-0.7.1-hbabe93e_0.conda#ff862eebdfeb2fd048ae9dc92510baca -https://conda.anaconda.org/conda-forge/linux-64/graphite2-1.3.13-h59595ed_1003.conda#f87c7b7c2cb45f323ffbce941c78ab7c -https://conda.anaconda.org/conda-forge/linux-64/icu-75.1-he02047a_0.conda#8b189310083baabfb622af68fd9d3ae3 -https://conda.anaconda.org/conda-forge/linux-64/lerc-4.0.0-h27087fc_0.tar.bz2#76bbff344f0134279f225174e9064c8f -https://conda.anaconda.org/conda-forge/linux-64/libcrc32c-1.1.2-h9c3ff4c_0.tar.bz2#c965a5aa0d5c1c37ffc62dff36e28400 -https://conda.anaconda.org/conda-forge/linux-64/libdrm-2.4.123-hb9d3cd8_0.conda#ee605e794bdc14e2b7f84c4faa0d8c2c -https://conda.anaconda.org/conda-forge/linux-64/libedit-3.1.20191231-he28a2e2_2.tar.bz2#4d331e44109e3f0e19b4cb8f9b82f3e1 -https://conda.anaconda.org/conda-forge/linux-64/libgfortran-ng-14.2.0-h69a702a_1.conda#0a7f4cd238267c88e5d69f7826a407eb -https://conda.anaconda.org/conda-forge/linux-64/libnghttp2-1.64.0-h161d5f1_0.conda#19e57602824042dfd0446292ef90488b -https://conda.anaconda.org/conda-forge/linux-64/libprotobuf-5.28.2-h5b01275_0.conda#ab0bff36363bec94720275a681af8b83 -https://conda.anaconda.org/conda-forge/linux-64/libre2-11-2024.07.02-hbbce691_1.conda#2124de47357b7a516c0a3efd8f88c143 -https://conda.anaconda.org/conda-forge/linux-64/libthrift-0.21.0-h0e7cc3e_0.conda#dcb95c0a98ba9ff737f7ae482aef7833 -https://conda.anaconda.org/conda-forge/linux-64/lz4-c-1.9.4-hcb278e6_0.conda#318b08df404f9c9be5712aaa5a6f0bb0 -https://conda.anaconda.org/conda-forge/linux-64/pcre2-10.44-hba22ea6_2.conda#df359c09c41cd186fffb93a2d87aa6f5 -https://conda.anaconda.org/conda-forge/linux-64/pixman-0.43.2-h59595ed_0.conda#71004cbf7924e19c02746ccde9fd7123 -https://conda.anaconda.org/conda-forge/linux-64/qhull-2020.2-h434a139_5.conda#353823361b1d27eb3960efb076dfcaf6 -https://conda.anaconda.org/conda-forge/linux-64/readline-8.2-h8228510_1.conda#47d31b792659ce70f470b5c82fdfb7a4 -https://conda.anaconda.org/conda-forge/linux-64/snappy-1.2.1-ha2e4443_0.conda#6b7dcc7349efd123d493d2dbe85a045f -https://conda.anaconda.org/conda-forge/linux-64/wayland-1.23.1-h3e06ad9_0.conda#0a732427643ae5e0486a727927791da1 -https://conda.anaconda.org/conda-forge/linux-64/xcb-util-0.4.1-hb711507_2.conda#8637c3e5821654d0edf97e2b0404b443 -https://conda.anaconda.org/conda-forge/linux-64/xcb-util-keysyms-0.4.1-hb711507_0.conda#ad748ccca349aec3e91743e08b5e2b50 -https://conda.anaconda.org/conda-forge/linux-64/xcb-util-renderutil-0.3.10-hb711507_0.conda#0e0cbe0564d03a99afd5fd7b362feecd -https://conda.anaconda.org/conda-forge/linux-64/xcb-util-wm-0.4.2-hb711507_0.conda#608e0ef8256b81d04456e8d211eee3e8 -https://conda.anaconda.org/conda-forge/linux-64/xorg-libsm-1.2.4-he73a12e_1.conda#05a8ea5f446de33006171a7afe6ae857 -https://conda.anaconda.org/conda-forge/linux-64/xorg-libx11-1.8.10-h4f16b4b_0.conda#0b666058a179b744a622d0a4a0c56353 -https://conda.anaconda.org/conda-forge/linux-64/zstd-1.5.6-ha6fb4c9_0.conda#4d056880988120e29d75bfff282e0f45 -https://conda.anaconda.org/conda-forge/linux-64/aws-c-event-stream-0.5.0-h1ffe551_7.conda#7cce4dfab184f4bbdfc160789251b3c5 -https://conda.anaconda.org/conda-forge/linux-64/aws-c-http-0.9.1-hab05fe4_2.conda#fb409f7053fa3dbbdf6eb41045a87795 -https://conda.anaconda.org/conda-forge/linux-64/brotli-1.1.0-hb9d3cd8_2.conda#98514fe74548d768907ce7a13f680e8f -https://conda.anaconda.org/conda-forge/linux-64/fontconfig-2.15.0-h7e30c49_1.conda#8f5b0b297b59e1ac160ad4beec99dbee -https://conda.anaconda.org/conda-forge/linux-64/krb5-1.21.3-h659f571_0.conda#3f43953b7d3fb3aaa1d0d0723d91e368 -https://conda.anaconda.org/conda-forge/linux-64/libglib-2.82.2-h2ff4ddf_0.conda#13e8e54035ddd2b91875ba399f0f7c04 -https://conda.anaconda.org/conda-forge/linux-64/libglx-1.7.0-ha4b6fd6_2.conda#c8013e438185f33b13814c5c488acd5c -https://conda.anaconda.org/conda-forge/linux-64/libopenblas-0.3.25-pthreads_h413a1c8_0.conda#d172b34a443b95f86089e8229ddc9a17 -https://conda.anaconda.org/conda-forge/linux-64/libtiff-4.7.0-he137b08_1.conda#63872517c98aa305da58a757c443698e -https://conda.anaconda.org/conda-forge/linux-64/libxml2-2.13.5-hb346dea_0.conda#c81a9f1118541aaa418ccb22190c817e -https://conda.anaconda.org/conda-forge/linux-64/mysql-libs-9.0.1-he0572af_2.conda#57a9e7ee3c0840d3c8c9012473978629 -https://conda.anaconda.org/conda-forge/linux-64/orc-2.0.3-he039a57_0.conda#052499acd6d6b79952197a13b23e2600 -https://conda.anaconda.org/conda-forge/linux-64/python-3.11.10-hc5c86c4_3_cpython.conda#9e1ad55c87368e662177661a998feed5 -https://conda.anaconda.org/conda-forge/linux-64/re2-2024.07.02-h77b4e00_1.conda#01093ff37c1b5e6bf9f17c0116747d11 -https://conda.anaconda.org/conda-forge/linux-64/xcb-util-image-0.4.0-hb711507_2.conda#a0901183f08b6c7107aab109733a3c91 -https://conda.anaconda.org/conda-forge/linux-64/xkeyboard-config-2.43-hb9d3cd8_0.conda#f725c7425d6d7c15e31f3b99a88ea02f -https://conda.anaconda.org/conda-forge/linux-64/xorg-libxext-1.3.6-hb9d3cd8_0.conda#febbab7d15033c913d53c7a2c102309d -https://conda.anaconda.org/conda-forge/linux-64/xorg-libxfixes-6.0.1-hb9d3cd8_0.conda#4bdb303603e9821baf5fe5fdff1dc8f8 -https://conda.anaconda.org/conda-forge/linux-64/xorg-libxrender-0.9.11-hb9d3cd8_1.conda#a7a49a8b85122b49214798321e2e96b4 -https://conda.anaconda.org/conda-forge/noarch/attrs-24.2.0-pyh71513ae_0.conda#6732fa52eb8e66e5afeb32db8701a791 -https://conda.anaconda.org/conda-forge/linux-64/aws-c-auth-0.8.0-hb88c0a9_10.conda#409b7ee6d3473cc62bda7280f6ac20d0 -https://conda.anaconda.org/conda-forge/linux-64/aws-c-mqtt-0.11.0-h7bd072d_8.conda#0e9d67838114c0dbd267a9311268b331 -https://conda.anaconda.org/conda-forge/linux-64/cairo-1.18.0-hebfffa5_3.conda#fceaedf1cdbcb02df9699a0d9b005292 -https://conda.anaconda.org/conda-forge/noarch/certifi-2024.8.30-pyhd8ed1ab_0.conda#12f7d00853807b0531775e9be891cb11 -https://conda.anaconda.org/conda-forge/noarch/cycler-0.12.1-pyhd8ed1ab_0.conda#5cd86562580f274031ede6aa6aa24441 -https://conda.anaconda.org/conda-forge/linux-64/cyrus-sasl-2.1.27-h54b06d7_7.conda#dce22f70b4e5a407ce88f2be046f4ceb -https://conda.anaconda.org/conda-forge/linux-64/dbus-1.13.6-h5008d03_3.tar.bz2#ecfff944ba3960ecb334b9a2663d708d -https://conda.anaconda.org/conda-forge/linux-64/kiwisolver-1.4.7-py311hd18a35c_0.conda#be34c90cce87090d24da64a7c239ca96 -https://conda.anaconda.org/conda-forge/linux-64/lcms2-2.16-hb7c19ff_0.conda#51bb7010fc86f70eee639b4bb7a894f5 -https://conda.anaconda.org/conda-forge/linux-64/libblas-3.9.0-20_linux64_openblas.conda#2b7bb4f7562c8cf334fc2e20c2d28abc -https://conda.anaconda.org/conda-forge/linux-64/libcups-2.3.3-h4637d8d_4.conda#d4529f4dff3057982a7617c7ac58fde3 -https://conda.anaconda.org/conda-forge/linux-64/libcurl-8.10.1-hbbe4b11_0.conda#6e801c50a40301f6978c53976917b277 -https://conda.anaconda.org/conda-forge/linux-64/libgl-1.7.0-ha4b6fd6_2.conda#928b8be80851f5d8ffb016f9c81dae7a -https://conda.anaconda.org/conda-forge/linux-64/libgrpc-1.67.1-hc2c308b_0.conda#4606a4647bfe857e3cfe21ca12ac3afb -https://conda.anaconda.org/conda-forge/linux-64/libllvm19-19.1.4-ha7bfdaf_1.conda#886acc67bcba28a5c6b429aad2f057ce -https://conda.anaconda.org/conda-forge/linux-64/libxkbcommon-1.7.0-h2c5496b_1.conda#e2eaefa4de2b7237af7c907b8bbc760a -https://conda.anaconda.org/conda-forge/linux-64/libxslt-1.1.39-h76b75d6_0.conda#e71f31f8cfb0a91439f2086fc8aa0461 -https://conda.anaconda.org/conda-forge/linux-64/markupsafe-3.0.2-py311h2dc5d0c_0.conda#15e4dadd59e93baad7275249f10b9472 -https://conda.anaconda.org/conda-forge/noarch/munkres-1.1.4-pyh9f0ad1d_0.tar.bz2#2ba8498c1018c1e9c61eb99b973dfe19 -https://conda.anaconda.org/conda-forge/noarch/mypy_extensions-1.0.0-pyha770c72_0.conda#4eccaeba205f0aed9ac3a9ea58568ca3 -https://conda.anaconda.org/conda-forge/linux-64/openjpeg-2.5.2-h488ebb8_0.conda#7f2e286780f072ed750df46dc2631138 -https://conda.anaconda.org/conda-forge/noarch/packaging-24.2-pyhff2d567_1.conda#8508b703977f4c4ada34d657d051972c -https://conda.anaconda.org/conda-forge/noarch/pkgutil-resolve-name-1.3.10-pyhd8ed1ab_1.conda#405678b942f2481cecdb3e010f4925d9 -https://conda.anaconda.org/conda-forge/noarch/pyparsing-3.2.0-pyhd8ed1ab_1.conda#035c17fbf099f50ff60bf2eb303b0a83 -https://conda.anaconda.org/conda-forge/noarch/python-tzdata-2024.2-pyhd8ed1ab_0.conda#986287f89929b2d629bd6ef6497dc307 -https://conda.anaconda.org/conda-forge/noarch/pytz-2024.2-pyhd8ed1ab_0.conda#260009d03c9d5c0f111904d851f053dc -https://conda.anaconda.org/conda-forge/linux-64/rpds-py-0.21.0-py311h9e33e62_0.conda#befdb32741d8686b860232ca80178d63 -https://conda.anaconda.org/conda-forge/noarch/setuptools-75.6.0-pyhff2d567_1.conda#fc80f7995e396cbaeabd23cf46c413dc -https://conda.anaconda.org/conda-forge/noarch/six-1.16.0-pyh6c4a22f_0.tar.bz2#e5f25f8dbc060e9a8d912e432202afc2 -https://conda.anaconda.org/conda-forge/noarch/threadpoolctl-3.5.0-pyhc1e730c_0.conda#df68d78237980a159bd7149f33c0e8fd -https://conda.anaconda.org/conda-forge/noarch/toolz-1.0.0-pyhd8ed1ab_0.conda#34feccdd4177f2d3d53c73fc44fd9a37 -https://conda.anaconda.org/conda-forge/linux-64/tornado-6.4.2-py311h9ecbd09_0.conda#df3aee9c3e44489257a840b8354e77b9 -https://conda.anaconda.org/conda-forge/noarch/types-pytz-2024.2.0.20241003-pyhd8ed1ab_0.conda#42775c62ac0671b0d700c754256d5c19 -https://conda.anaconda.org/conda-forge/noarch/typing_extensions-4.12.2-pyha770c72_0.conda#ebe6952715e1d5eb567eeebf25250fa7 -https://conda.anaconda.org/conda-forge/linux-64/unicodedata2-15.1.0-py311h9ecbd09_1.conda#00895577e2b4c24dca76675ab1862551 -https://conda.anaconda.org/conda-forge/noarch/wheel-0.45.1-pyhd8ed1ab_0.conda#bdb2f437ce62fd2f1fef9119a37a12d9 -https://conda.anaconda.org/conda-forge/linux-64/wrapt-1.17.0-py311h9ecbd09_0.conda#452e39fb544b1ec9cc6c5b2ac9c47efa -https://conda.anaconda.org/conda-forge/linux-64/xcb-util-cursor-0.1.5-hb9d3cd8_0.conda#eb44b3b6deb1cab08d72cb61686fe64c -https://conda.anaconda.org/conda-forge/linux-64/xorg-libxcomposite-0.4.6-hb9d3cd8_2.conda#d3c295b50f092ab525ffe3c2aa4b7413 -https://conda.anaconda.org/conda-forge/linux-64/xorg-libxcursor-1.2.3-hb9d3cd8_0.conda#2ccd714aa2242315acaf0a67faea780b -https://conda.anaconda.org/conda-forge/linux-64/xorg-libxdamage-1.1.6-hb9d3cd8_0.conda#b5fcc7172d22516e1f965490e65e33a4 -https://conda.anaconda.org/conda-forge/linux-64/xorg-libxi-1.8.2-hb9d3cd8_0.conda#17dcc85db3c7886650b8908b183d6876 -https://conda.anaconda.org/conda-forge/linux-64/xorg-libxrandr-1.5.4-hb9d3cd8_0.conda#2de7f99d6581a4a7adbff607b5c278ca -https://conda.anaconda.org/conda-forge/linux-64/xorg-libxxf86vm-1.1.5-hb9d3cd8_4.conda#7da9007c0582712c4bad4131f89c8372 -https://conda.anaconda.org/conda-forge/noarch/zipp-3.21.0-pyhd8ed1ab_0.conda#fee389bf8a4843bd7a2248ce11b7f188 -https://conda.anaconda.org/conda-forge/linux-64/aws-c-s3-0.7.2-h3a84f74_0.conda#a5f883ce16928e898856b5bd8d1bee57 -https://conda.anaconda.org/conda-forge/linux-64/azure-core-cpp-1.14.0-h5cfcd09_0.conda#0a8838771cc2e985cd295e01ae83baf1 -https://conda.anaconda.org/conda-forge/linux-64/fonttools-4.55.0-py311h2dc5d0c_0.conda#8b056dbb53df32a9dbf1718a04dc4138 -https://conda.anaconda.org/conda-forge/linux-64/harfbuzz-9.0.0-hda332d3_1.conda#76b32dcf243444aea9c6b804bcfa40b8 -https://conda.anaconda.org/conda-forge/noarch/importlib-metadata-8.5.0-pyha770c72_0.conda#54198435fce4d64d8a89af22573012a8 -https://conda.anaconda.org/conda-forge/noarch/importlib_resources-6.4.5-pyhd8ed1ab_0.conda#c808991d29b9838fb4d96ce8267ec9ec -https://conda.anaconda.org/conda-forge/noarch/jinja2-3.1.4-pyhd8ed1ab_0.conda#7b86ecb7d3557821c649b3c31e3eb9f2 -https://conda.anaconda.org/conda-forge/noarch/joblib-1.4.2-pyhd8ed1ab_0.conda#25df261d4523d9f9783bcdb7208d872f -https://conda.anaconda.org/conda-forge/linux-64/libcblas-3.9.0-20_linux64_openblas.conda#36d486d72ab64ffea932329a1d3729a3 -https://conda.anaconda.org/conda-forge/linux-64/libclang-cpp19.1-19.1.4-default_hb5137d0_0.conda#e7e4a0ebe1f6eedf483f6f5d4f7d2bdd -https://conda.anaconda.org/conda-forge/linux-64/libclang13-19.1.4-default_h9c6a7e4_0.conda#6c450adae455c7d648856e8b0cfcebd6 -https://conda.anaconda.org/conda-forge/linux-64/libgoogle-cloud-2.31.0-h804f50b_0.conda#35ab838423b60f233391eb86d324a830 -https://conda.anaconda.org/conda-forge/linux-64/liblapack-3.9.0-20_linux64_openblas.conda#6fabc51f5e647d09cc010c40061557e0 -https://conda.anaconda.org/conda-forge/linux-64/openldap-2.6.9-he970967_0.conda#ca2de8bbdc871bce41dbf59e51324165 -https://conda.anaconda.org/conda-forge/linux-64/pillow-11.0.0-py311h49e9ac3_0.conda#2bd3d0f839ec0d1eaca817c9d1feb7c2 -https://conda.anaconda.org/conda-forge/noarch/pip-24.3.1-pyh8b19718_0.conda#5dd546fe99b44fda83963d15f84263b7 -https://conda.anaconda.org/conda-forge/noarch/python-dateutil-2.9.0.post0-pyhff2d567_0.conda#b6dfd90a2141e573e4b6a81630b56df5 -https://conda.anaconda.org/conda-forge/noarch/referencing-0.35.1-pyhd8ed1ab_0.conda#0fc8b52192a8898627c3efae1003e9f6 -https://conda.anaconda.org/conda-forge/noarch/typing-extensions-4.12.2-hd8ed1ab_0.conda#52d648bd608f5737b123f510bb5514b5 -https://conda.anaconda.org/conda-forge/noarch/typing_inspect-0.9.0-pyhd8ed1ab_0.conda#9e924b76b91908a17e28a19a0ab88687 -https://conda.anaconda.org/conda-forge/linux-64/xorg-libxtst-1.2.5-hb9d3cd8_3.conda#7bbe9a0cc0df0ac5f5a8ad6d6a11af2f -https://conda.anaconda.org/conda-forge/noarch/annotated-types-0.7.0-pyhd8ed1ab_0.conda#7e9f4612544c8edbfd6afad17f1bd045 -https://conda.anaconda.org/conda-forge/linux-64/aws-crt-cpp-0.29.5-h0e61686_1.conda#7143a281febcabfc242a458b7bc12048 -https://conda.anaconda.org/conda-forge/linux-64/azure-identity-cpp-1.10.0-h113e628_0.conda#73f73f60854f325a55f1d31459f2ab73 -https://conda.anaconda.org/conda-forge/linux-64/azure-storage-common-cpp-12.8.0-h736e048_1.conda#13de36be8de3ae3f05ba127631599213 -https://conda.anaconda.org/conda-forge/noarch/jsonschema-specifications-2024.10.1-pyhd8ed1ab_0.conda#720745920222587ef942acfbc578b584 -https://conda.anaconda.org/conda-forge/linux-64/libgoogle-cloud-storage-2.31.0-h0121fbd_0.conda#568d6a09a6ed76337a7b97c84ae7c0f8 -https://conda.anaconda.org/conda-forge/linux-64/libpq-17.2-h04577a9_0.conda#52dd46162c6fb2765b49e6fd06adf8d5 -https://conda.anaconda.org/conda-forge/linux-64/numpy-1.26.0-py311h64a7726_0.conda#bf16a9f625126e378302f08e7ed67517 -https://conda.anaconda.org/conda-forge/linux-64/pydantic-core-2.27.1-py311h9e33e62_0.conda#e5192dfb2dae866470c3eec81dbe5727 -https://conda.anaconda.org/conda-forge/linux-64/aws-sdk-cpp-1.11.449-hdaa582e_3.conda#0dca4b37cf80312f8ef84b649e6ad3a3 -https://conda.anaconda.org/conda-forge/linux-64/azure-storage-blobs-cpp-12.13.0-h3cf044e_1.conda#7eb66060455c7a47d9dcdbfa9f46579b -https://conda.anaconda.org/conda-forge/linux-64/contourpy-1.3.1-py311hd18a35c_0.conda#351cb68d2081e249069748b6e60b3cd2 -https://conda.anaconda.org/conda-forge/noarch/jsonschema-4.23.0-pyhd8ed1ab_0.conda#da304c192ad59975202859b367d0f6a2 -https://conda.anaconda.org/conda-forge/linux-64/pandas-2.2.2-py311h14de704_1.conda#84e2dd379d4edec4dd6382861486104d -https://conda.anaconda.org/conda-forge/noarch/pandas-stubs-2.2.3.241126-pyhd8ed1ab_0.conda#aaa91eeaa0b20de3d50cd8a763afec23 -https://conda.anaconda.org/conda-forge/noarch/patsy-1.0.1-pyhff2d567_0.conda#a97b9c7586cedcf4a0a158ef3479975c -https://conda.anaconda.org/conda-forge/noarch/pydantic-2.10.2-pyh3cfb1c2_0.conda#e661b732b4d7514ace55a01873f03201 -https://conda.anaconda.org/conda-forge/linux-64/qt6-main-6.8.0-h6e8976b_0.conda#6d1c5d2d904d24c17cbb538a95855a4e -https://conda.anaconda.org/conda-forge/linux-64/scipy-1.11.2-py311h64a7726_1.conda#58af16843fc4469770bdbaf45d3a19de -https://conda.anaconda.org/conda-forge/noarch/altair-5.1.0-pyhd8ed1ab_0.conda#1c6b73b9239b27acc654428e97536142 -https://conda.anaconda.org/conda-forge/linux-64/azure-storage-files-datalake-cpp-12.12.0-ha633028_1.conda#7c1980f89dd41b097549782121a73490 -https://conda.anaconda.org/conda-forge/linux-64/matplotlib-base-3.9.2-py311h2b939e6_2.conda#2e8401a7780e33e9ca76034d0ed24c3c -https://conda.anaconda.org/conda-forge/linux-64/pyside6-6.8.0.2-py311h9053184_0.conda#a09628d42965b2102f929650b6c90f0d -https://conda.anaconda.org/conda-forge/linux-64/scikit-learn-1.3.2-py311hc009520_2.conda#9821f8e497a791858226f535e5e0be62 -https://conda.anaconda.org/conda-forge/linux-64/statsmodels-0.14.4-py311h9f3472d_0.conda#81e81b5b7a744fcb279e98aa6d2e6683 -https://conda.anaconda.org/conda-forge/linux-64/libarrow-18.1.0-h94eee4b_0_cpu.conda#1718fa336f42a0b24b822457df7ce43d -https://conda.anaconda.org/conda-forge/linux-64/matplotlib-3.9.2-py311h38be061_2.conda#713b57fc1ebd395598f709a26c2d27fd -https://conda.anaconda.org/conda-forge/noarch/seaborn-base-0.13.2-pyhd8ed1ab_2.conda#b713b116feaf98acdba93ad4d7f90ca1 -https://conda.anaconda.org/conda-forge/linux-64/libarrow-acero-18.1.0-h5888daf_0_cpu.conda#d2f94a6f24f028544c7a4cb1b50c5eca -https://conda.anaconda.org/conda-forge/linux-64/libparquet-18.1.0-h6bd9018_0_cpu.conda#580349cffeac814a32ff661dcbe72821 -https://conda.anaconda.org/conda-forge/linux-64/pyarrow-core-18.1.0-py311h4854187_0_cpu.conda#830a64ee7a65e588c7ea615be84db2e3 -https://conda.anaconda.org/conda-forge/noarch/seaborn-0.13.2-hd8ed1ab_2.conda#a79d8797f62715255308d92d3a91ef2e -https://conda.anaconda.org/conda-forge/linux-64/libarrow-dataset-18.1.0-h5888daf_0_cpu.conda#7834b3a11d0f1ee7e13b4533e361586f -https://conda.anaconda.org/conda-forge/linux-64/libarrow-substrait-18.1.0-h5c8f2c3_0_cpu.conda#51dc5a7117ec264e0a5cc1a5d82437dd -https://conda.anaconda.org/conda-forge/linux-64/pyarrow-18.1.0-py311h38be061_0.conda#47b8624012486e05e66f6acf7267aa22 -https://conda.anaconda.org/conda-forge/noarch/pandera-base-0.9.0-pyhd8ed1ab_0.tar.bz2#e6650f932be500fd69683912b132cf75 -https://conda.anaconda.org/conda-forge/noarch/pandera-0.9.0-hd8ed1ab_0.tar.bz2#6d43df178223baa7f217547838571817 -# pip vega-datasets @ https://files.pythonhosted.org/packages/e6/9f/ca52771fe972e0dcc5167fedb609940e01516066938ff2ee28b273ae4f29/vega_datasets-0.9.0-py3-none-any.whl#sha256=3d7c63917be6ca9b154b565f4779a31fedce57b01b5b9d99d8a34a7608062a1d -# pip altair-ally @ https://files.pythonhosted.org/packages/ca/b3/df528cb8c8242485b7f5d4d973fea5233b216486b3e1d2d8b14d92772ddf/altair_ally-0.1.1.tar.gz#sha256=f8b7179fda6335322048f71ec29b827b63f658e8a9fb54426927597eeb1f446e diff --git a/.ipynb_checkpoints/download-checkpoint.py b/.ipynb_checkpoints/download-checkpoint.py deleted file mode 100644 index a2302a4..0000000 --- a/.ipynb_checkpoints/download-checkpoint.py +++ /dev/null @@ -1,51 +0,0 @@ -import os -import pandas as pd -import click - - -def read_csv(directory, filename): - """ - Read a CSV file from the given specified directory. - - Parameters: - ---------- - directory : str - The directory where the CSV file is located. - filename : str - The name of the CSV file to be read. - - Returns: - ------- - DataFrame, str - The loaded DataFrame and the full file path. - """ - file_path = os.path.join(directory, filename) - if not os.path.isfile(file_path): - raise FileNotFoundError(f"The file {filename} does not exist in the directory {directory}.") - try: - df = pd.read_csv(file_path) - print(f"Successfully read the CSV file from {file_path}") - return df, file_path - except Exception as e: - raise Exception(f"An error occurred while reading the CSV file: {e}") - - -@click.command() -@click.option('--directory', type=str, default='data/bankmarketing/bank-additional/bank-additional/', help="Directory where the CSV file is located.") -@click.option('--filename', type=str, default='bank-additional-full.csv', help="Name of the CSV file.") -def main(directory, filename): - """ - Reads a CSV file from a specified directory and prints its contents. - Also outputs the file path for use in other scripts. - """ - try: - _, file_path = read_csv(directory, filename) - - # Output the file path for the next script - print(f"File saved to: {file_path}") - except Exception as e: - print(f"Error: {e}") - - -if __name__ == "__main__": - main()