From dcbd1d85e785a8be53c82b16cee91b9161e77ecf Mon Sep 17 00:00:00 2001 From: dhrey Date: Mon, 16 Nov 2020 21:19:59 +0100 Subject: [PATCH] Updating the project-my assgnment --- .../DataPrep-checkpoint.ipynb | 342 +++ Data Prep/DataPrep.ipynb | 2 +- .../decision_trees-checkpoint.ipynb | 1763 ++++++++++++++ Decision Trees/decision_trees.ipynb | 208 +- .../Linear_Algebra-checkpoint.ipynb | 1142 +++++++++ Linear Algebra/Linear_Algebra.ipynb | 2 +- .../linear_regression-checkpoint.ipynb | 2131 +++++++++++++++++ Linear Regression/linear_regression.ipynb | 2 +- .../logistic_regression-checkpoint.ipynb | 2111 ++++++++++++++++ Logistic Regression/logistic_regression.ipynb | 6 +- .../probability-checkpoint.ipynb | 464 ++++ Probabilty/probability.ipynb | 2 +- ...se Nigeria Project 'name'-checkpoint.ipynb | 1231 ++++++++++ ...020 ML Course Nigeria Project 'name'.ipynb | 2090 +++++++++++++++- .../regularization-checkpoint.ipynb | 1307 ++++++++++ Regularization/regularization.ipynb | 2 +- .../unsupervised_learning-checkpoint.ipynb | 1019 ++++++++ .../unsupervised_learning.ipynb | 2 +- 18 files changed, 13577 insertions(+), 249 deletions(-) create mode 100644 Data Prep/.ipynb_checkpoints/DataPrep-checkpoint.ipynb create mode 100644 Decision Trees/.ipynb_checkpoints/decision_trees-checkpoint.ipynb create mode 100644 Linear Algebra/.ipynb_checkpoints/Linear_Algebra-checkpoint.ipynb create mode 100644 Linear Regression/.ipynb_checkpoints/linear_regression-checkpoint.ipynb create mode 100644 Logistic Regression/.ipynb_checkpoints/logistic_regression-checkpoint.ipynb create mode 100644 Probabilty/.ipynb_checkpoints/probability-checkpoint.ipynb create mode 100644 Project/.ipynb_checkpoints/09-11-2020 ML Course Nigeria Project 'name'-checkpoint.ipynb create mode 100644 Regularization/.ipynb_checkpoints/regularization-checkpoint.ipynb create mode 100644 Unsupervised Learning/.ipynb_checkpoints/unsupervised_learning-checkpoint.ipynb diff --git a/Data Prep/.ipynb_checkpoints/DataPrep-checkpoint.ipynb b/Data Prep/.ipynb_checkpoints/DataPrep-checkpoint.ipynb new file mode 100644 index 0000000..96abb28 --- /dev/null +++ b/Data Prep/.ipynb_checkpoints/DataPrep-checkpoint.ipynb @@ -0,0 +1,342 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + " \"Open\n", + "" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + " All rights reserved © Global AI Hub 2020 \n", + "![](img/logo.png)\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Building ML Project" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "![](img/flow.png)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Steps of Project\n", + "\n", + "- Gathering Data\n", + "- Preparing the Data\n", + "- Choosing Models\n", + "- Training\n", + "- Evaluation\n", + "- Hyperparameter Tuning\n", + "- Prediction\n", + "- Model Selection" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 1) Gathering Data" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "After the problem definition, we need to obtain data which will be appropriate for our case. The quality and quantity of data that you gather will directly determine how good our predictive model can be." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 2) Preparing the Data" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Data preparation, where we load our data into a suitable place and prepare it for use in our machine learning training. This is also a good time to do any pertinent visualizations of your data, to help you see if there are any relevant relationships between different variables you can take advantage of, as well as show you if there are any data imbalances." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Exploratory Data Analysis (EDA)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Exploratory Data Analysis refers to the critical process of performing initial investigations on data so as to discover patterns,to spot anomalies,to test hypothesis and to check assumptions with the help of summary statistics and graphical representations." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "![](img/wordcloud.jpg)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "![](img/hist2.png)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "![](img/bar2.png)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Pre-Processing" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Duplicate Values\n", + "In most cases, the duplicates are removed so as to not give that particular data object an advantage or bias, when running machine learning algorithms." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Imbalanced Data\n", + "An Imbalanced dataset is one where the number of instances of a class(es) are significantly higher than another class(es), thus leading to an imbalance and creating rarer class(es)." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "![](img/imbalance.png)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Missing Values\n", + "\n", + "- Eleminate missing values\n", + "- Filling with mean or median\n", + "\n", + "`df.isnull().sum() ` \n", + "`df.dropna()`" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "![](img/skew.jpg)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Outlier Detection\n", + "\n", + "- Standart Deviation\n", + "- Box Plots / IQR Calculation\n", + "- Isolation Forest\n", + "\n", + "\n", + "`from sklearn.ensemble import IsolationForest`" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "![](img/stddev.png)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "![](img/IQR.png)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Feature Scaling\n", + "\n", + "- Standardization \n", + "$$ X_{new} = \\frac{X-\\mu}{\\sigma} $$ \n", + "- Normalization \n", + "$$X_{new} = \\frac{X-X_{min}}{X_{max} - X_{min}} $$ \n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "![](img/stndr.png)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "![](img/norm.png)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Bucketing (Binning)\n", + "\n", + "Data binning, bucketing is a data pre-processing method used to minimize the effects of small observation errors (noisy data). The original data values are divided into small intervals known as bins and then they are replaced by a general value calculated for that bin. \n", + "\n", + "![](img/binning.png)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Feature Extraction\n", + "- Principle Components Analysis (PCA)\n", + "- Independent Component Analysis (ICA)\n", + "- Linear Discriminant Analysis (LDA)\n", + "- t-distributed Stochastic Neighbor Embedding (t-SNE)\n", + "\n", + "Example: \n", + "$$Profit = Revenue - Cost$$" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Feature Encoding\n", + "Feature encoding is basically performing transformations on the data such that it can be easily accepted as input for machine learning algorithms while still retaining its original meaning.\n", + "\n", + "- **Nominal** : Any one-to-one mapping can be done which retains the meaning. For instance, a permutation of values like in One-Hot Encoding.\n", + "- **Ordinal** : An order-preserving change of values. The notion of small, medium and large can be represented equally well with the help of a new function. For example, we can encode this S, M and L sizes into {0, 1, 2} or maybe {1, 2, 3}." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "![](img/encode.png)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Train / Validation / Test Split" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "But before we start deciding the algorithm which should be used, it is always advised to split the dataset into 2 or sometimes 3 parts. Machine Learning algorithms, or any algorithm for that matter, has to be first trained on the data distribution available and then validated and tested, before it can be deployed to deal with real-world data. \n", + "\n", + "- 60 / 20 / 20\n", + "- 70 / 30\n", + "\n", + "`from sklearn.model_selection import train_test_split`" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "![](img/split.png)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "---\n", + "#### Cross Validation\n", + "\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "![](img/cross_valid.png)\n", + "`from sklearn.model_selection import cross_validate`\n", + "\n", + "https://scikit-learn.org/stable/modules/cross_validation.html" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Resources\n", + "\n", + "https://towardsdatascience.com/introduction-to-data-preprocessing-in-machine-learning-a9fa83a5dc9d \n", + "https://developers.google.com/machine-learning/data-prep \n", + "https://towardsdatascience.com/5-ways-to-detect-outliers-that-every-data-scientist-should-know-python-code-70a54335a623\n", + "https://machinelearningmastery.com/feature-selection-with-real-and-categorical-data/ \n", + "https://towardsdatascience.com/scale-standardize-or-normalize-with-scikit-learn-6ccc7d176a02 \n", + "https://towardsdatascience.com/the-5-feature-selection-algorithms-every-data-scientist-need-to-know-3a6b566efd2 \n" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.7.3" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/Data Prep/DataPrep.ipynb b/Data Prep/DataPrep.ipynb index 96abb28..ba27e1d 100644 --- a/Data Prep/DataPrep.ipynb +++ b/Data Prep/DataPrep.ipynb @@ -334,7 +334,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.7.3" + "version": "3.7.9" } }, "nbformat": 4, diff --git a/Decision Trees/.ipynb_checkpoints/decision_trees-checkpoint.ipynb b/Decision Trees/.ipynb_checkpoints/decision_trees-checkpoint.ipynb new file mode 100644 index 0000000..13b5e38 --- /dev/null +++ b/Decision Trees/.ipynb_checkpoints/decision_trees-checkpoint.ipynb @@ -0,0 +1,1763 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + " \"Open\n", + "" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "![](img/logo.png)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Decision Tree" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "A decision tree is one of the supervised machine learning algorithms. This algorithm can be used for regression and classification problems — yet, is mostly used for classification problems. As the name goes, it uses a tree-like model of decisions." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "![](img/Decision_Tree.jpg)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Terminology\n", + "\n", + "**Root Node**: This attribute is used for dividing the data into two or more sets. The feature attribute in this node is selected based on Attribute Selection Techniques. \n", + "
\n", + "**Branch or Sub-Tree**: A part of the entire decision tree is called branch or sub-tree. \n", + "
\n", + "**Splitting**: Dividing a node into two or more sub-nodes based on if-else conditions. \n", + "
\n", + "**Decision Node**: After splitting the sub-nodes into further sub-nodes, then it is called as the decision node. \n", + "
\n", + "**Leaf or Terminal Node**: This is the end of the decision tree where it cannot be split into further sub-nodes. \n", + "
\n", + "**Pruning:** Removing a sub-node from the tree is called pruning. \n", + "
" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Splitting\n", + "\n", + "We have 2 main splitting criteria to make decision how we split our data:\n", + "- Gini Index\n", + "- Information Gain\n", + "\n", + "#### Gini Index\n", + "Gini Index, also known as Gini impurity, calculates the amount of probability of a specific feature that is classified incorrectly when selected randomly. If all the elements are linked with a single class then it can be called pure.\n", + "\n", + "Gini index varies between values 0 and 1, where 0 expresses the purity of classification, i.e. All the elements belong to a specified class or only one class exists there. And 1 indicates the random distribution of elements across various classes. The value of 0.5 of the Gini Index shows an equal distribution of elements over some classes.\n", + "\n", + "Node gini index = $p^2 + q^2$ \n", + "Where: \n", + "$p$: probability for success \n", + "$q$: probability for failure ($1-p$)\n", + "\n", + "Weighted Gini score of each node of that split = $\\sum$ proportion of element in node $*$ gini index" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "![](img/split.png)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "![](\\img/split.png)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**Split on Gender**: \n", + "
\n", + "Calculate, Gini for sub-node Female = (0.2) * (0.2) + (0.8) * (0.8)=0.68 \n", + "Gini for sub-node Male = (0.65) * (0.65) + (0.35) * (0.35)=0.55 \n", + "Calculate weighted Gini for Split Gender = *(10/30)* * 0.68 + *(20/30)* * 0.55 = 0.59 \n", + "
\n", + "**Similar for Split on Class:** \n", + "Gini for sub-node Class IX = (0.43) * (0.43)+ (0.57) * (0.57) = 0.51 \n", + "Gini for sub-node Class X = (0.56) * (0.56) + (0.44) * (0.44) = 0.51 \n", + "Calculate weighted Gini for Split Class = (14/30) * 0.51 + (16/30) * 0.51 = 0.51 \n", + "\n", + "Above, you can see that Gini score for Split on Gender is higher than Split on Class, hence, the node split will take place on Gender." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Information Gain\n", + "\n", + "Information Gain is applied to quantify which feature provides maximal information about the classification based on the notion of entropy, i.e. by quantifying the size of uncertainty, disorder or impurity, in general, with the intention of decreasing the amount of entropy initiating from the top (root node) to bottom(leaves nodes). \n", + "\n", + "Less impure node requires less information to describe it. And, more impure node requires more information. Information theory is a measure to define this degree of disorganization in a system known as Entropy. If the sample is completely homogeneous, then the entropy is zero and if the sample is an equally divided (50% – 50%), it has entropy of one. \n", + "
\n", + "Information Gain = entropy (parent) - weighted average * entropy (children) \n", + "
\n", + "Entropy = $-p \\log_np - q \\log_nq$ \n", + "
\n", + "Where:\n", + "
\n", + "$p$: probability for success\n", + "
\n", + "$q$: probability for failure ($1-p$)\n", + "
\n", + "$n$: number of classes in label" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "Example:\n", + "
\n", + "Entropy for parent node = -(15/30) $\\log_2$ (15/30) – (15/30) $\\log_2$ (15/30) = 1. Here 1 shows that it is a impure node. \n", + "
\n", + "Entropy for Female node = -(2/10) $\\log_2$ (2/10) – (8/10) $\\log_2$ (8/10) = 0.72 and for male node, -(13/20) log2 (13/20) – (7/20) log2 (7/20) = 0.93 \n", + "
\n", + "Entropy for split Gender = Weighted entropy of sub-nodes = (10/30) * 0.72 + (20/30) * 0.93 = 0.86 \n", + "
\n", + "Entropy for Class IX node, -(6/14) $\\log_2$ (6/14) – (8/14) $\\log_2$ (8/14) = 0.99 and for Class X node, -(9/16) $\\log_2$ (9/16) – (7/16) $\\log_2$ (7/16) = 0.99. \n", + "
\n", + "Entropy for split Class = (14/30) * 0.99 + (16/30) * 0.99 = 0.99 \n", + "\n", + "Above, you can see that entropy for Split on Gender is the lowest among all, so the tree will split on Gender. We can derive information gain from entropy as **1- Entropy**. The lesser the entropy, the better it is." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Advantages of Decision Trees\n", + "- Simple to understand, interpret, visualize.\n", + "- Decision tree algorithm implementation can be done without scaling the data as well.\n", + "- Decision trees implicitly perform variable screening or feature selection.\n", + "- Nonlinear relationships between parameters do not affect tree performance. \n", + "
\n", + "\n", + "### Disadvantages of Decision Trees\n", + "- Decision-tree learners can create over-complex trees that do not generalize the data well. This is called overfitting.\n", + "- Decision trees can be unstable because small variations in the data might result in a completely different tree being generated. This is called variance, which needs to be lowered by methods like bagging and boosting.\n", + "- Greedy algorithms cannot guarantee to return the globally optimal decision tree. This can be mitigated by training multiple trees, where the features and samples are randomly sampled with replacement.(Random Forests)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "---" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Code" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import pandas as pd\n", + "import seaborn as sns\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "plt.rcParams['figure.figsize'] = (20.0, 10.0)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Read Data" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "data = pd.read_csv(\"datasets/iris.csv\")" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
IdSepalLengthCmSepalWidthCmPetalLengthCmPetalWidthCmSpecies
015.13.51.40.2Iris-setosa
124.93.01.40.2Iris-setosa
234.73.21.30.2Iris-setosa
344.63.11.50.2Iris-setosa
455.03.61.40.2Iris-setosa
\n", + "
" + ], + "text/plain": [ + " Id SepalLengthCm SepalWidthCm PetalLengthCm PetalWidthCm Species\n", + "0 1 5.1 3.5 1.4 0.2 Iris-setosa\n", + "1 2 4.9 3.0 1.4 0.2 Iris-setosa\n", + "2 3 4.7 3.2 1.3 0.2 Iris-setosa\n", + "3 4 4.6 3.1 1.5 0.2 Iris-setosa\n", + "4 5 5.0 3.6 1.4 0.2 Iris-setosa" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "data.head()" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "RangeIndex: 150 entries, 0 to 149\n", + "Data columns (total 6 columns):\n", + " # Column Non-Null Count Dtype \n", + "--- ------ -------------- ----- \n", + " 0 Id 150 non-null int64 \n", + " 1 SepalLengthCm 150 non-null float64\n", + " 2 SepalWidthCm 150 non-null float64\n", + " 3 PetalLengthCm 150 non-null float64\n", + " 4 PetalWidthCm 150 non-null float64\n", + " 5 Species 150 non-null object \n", + "dtypes: float64(4), int64(1), object(1)\n", + "memory usage: 7.2+ KB\n" + ] + } + ], + "source": [ + "data.info()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Describe" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
IdSepalLengthCmSepalWidthCmPetalLengthCmPetalWidthCm
count150.000000150.000000150.000000150.000000150.000000
mean75.5000005.8433333.0540003.7586671.198667
std43.4453680.8280660.4335941.7644200.763161
min1.0000004.3000002.0000001.0000000.100000
25%38.2500005.1000002.8000001.6000000.300000
50%75.5000005.8000003.0000004.3500001.300000
75%112.7500006.4000003.3000005.1000001.800000
max150.0000007.9000004.4000006.9000002.500000
\n", + "
" + ], + "text/plain": [ + " Id SepalLengthCm SepalWidthCm PetalLengthCm PetalWidthCm\n", + "count 150.000000 150.000000 150.000000 150.000000 150.000000\n", + "mean 75.500000 5.843333 3.054000 3.758667 1.198667\n", + "std 43.445368 0.828066 0.433594 1.764420 0.763161\n", + "min 1.000000 4.300000 2.000000 1.000000 0.100000\n", + "25% 38.250000 5.100000 2.800000 1.600000 0.300000\n", + "50% 75.500000 5.800000 3.000000 4.350000 1.300000\n", + "75% 112.750000 6.400000 3.300000 5.100000 1.800000\n", + "max 150.000000 7.900000 4.400000 6.900000 2.500000" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "data.describe()" + ] + }, + { + "cell_type": "code", + "execution_count": 40, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "RangeIndex: 150 entries, 0 to 149\n", + "Data columns (total 6 columns):\n", + " # Column Non-Null Count Dtype \n", + "--- ------ -------------- ----- \n", + " 0 Id 150 non-null int64 \n", + " 1 SepalLengthCm 150 non-null float64\n", + " 2 SepalWidthCm 150 non-null float64\n", + " 3 PetalLengthCm 150 non-null float64\n", + " 4 PetalWidthCm 150 non-null float64\n", + " 5 Species 150 non-null object \n", + "dtypes: float64(4), int64(1), object(1)\n", + "memory usage: 7.2+ KB\n" + ] + } + ], + "source": [ + "data.info()" + ] + }, + { + "cell_type": "code", + "execution_count": 41, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Id 0\n", + "SepalLengthCm 0\n", + "SepalWidthCm 0\n", + "PetalLengthCm 0\n", + "PetalWidthCm 0\n", + "Species 0\n", + "dtype: int64" + ] + }, + "execution_count": 41, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "data.isna().sum()" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
IdSepalLengthCmSepalWidthCmPetalLengthCmPetalWidthCm
Species
Iris-setosa5050505050
Iris-versicolor5050505050
Iris-virginica5050505050
\n", + "
" + ], + "text/plain": [ + " Id SepalLengthCm SepalWidthCm PetalLengthCm PetalWidthCm\n", + "Species \n", + "Iris-setosa 50 50 50 50 50\n", + "Iris-versicolor 50 50 50 50 50\n", + "Iris-virginica 50 50 50 50 50" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "data.groupby(by=\"Species\").count()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Visualize" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [], + "source": [ + "plt.rcParams['figure.figsize'] = (20.0, 10.0)" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAABI8AAAJNCAYAAAC4BVWHAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjMsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+AADFEAAAgAElEQVR4nOzdeXiU1d3/8c/JZLLvCTtCQFzYQsAAFRFQHsFH6oIrVamKoq2iaKu1trWiladWW7dq688u7guoxSJaF1QWAcUEAgiIWAQEwpKdLJPMcn5/BCIhGQiSO5MM79d15Qrzve+Z851MyPLJOec21loBAAAAAAAATYkIdQMAAAAAAABouwiPAAAAAAAAEBThEQAAAAAAAIIiPAIAAAAAAEBQhEcAAAAAAAAIivAIAAAAAAAAQUWGuoEjlZGRYTMzM0PdBgAAAAAAQNjIy8srtNZ2aOpYuwuPMjMzlZubG+o2AAAAAAAAwoYxZkuwY44vWzPGuIwxK40x85o4drUxZo8xJn/f23VO9wMAAAAAAIDma42ZR9MlrZeUFOT4LGvttFboAwAAAAAAAEfI0ZlHxpjukiZI+ruT4wAAAAAAAMAZTs88elTSLyQlHuKci4wxoyR9Jek2a+23DvcEAAAAAAAc5vV6tW3bNnk8nlC3ggPExMSoe/fucrvdzb6PY+GRMeaHknZba/OMMWOCnPaWpFestTXGmJ9Iek7SmU081vWSrpekHj16ONQxAAAAAABoKdu2bVNiYqIyMzNljAl1O5BkrVVRUZG2bdumXr16Nft+Ti5bO03SecaYzZJelXSmMebFA0+w1hZZa2v23fybpFOaeiBr7dPW2hxrbU6HDk1eNQ4AAAAAALQhHo9H6enpBEdtiDFG6enpRzwbzLHwyFp7l7W2u7U2U9IkSR9Za6888BxjTJcDbp6nuo21AQAAAABAGCA4anu+z2vi6IbZTTHG3GeMOW/fzVuMMWuNMask3SLp6tbuBwAAAAAAhKeZM2eqf//+ysrKUnZ2tj777LMWe+xzzjlHpaWlLfZ4bZnTG2ZLkqy1CyQt2Pfv3x5Qv0vSXa3RAwAAAAAAOHYsW7ZM8+bN04oVKxQdHa3CwkLV1ta22OO/8847LfZYbV2rzzwCAAAAAABwWkFBgTIyMhQdHS1JysjIUNeuXZWZmak777xTw4YN07Bhw/T1119Lkvbs2aOLLrpIQ4cO1dChQ7VkyRJJUkVFha655hoNHDhQWVlZeuONNyRJmZmZKiwslCS9+OKLGjZsmLKzs3XDDTfI7/fL7/fr6quv1oABAzRw4EA98sgjIfgotAzCIwAAAAAAEHbGjRunb7/9VieeeKJuvPFGLVy4sP5YUlKSli9frmnTpunWW2+VJE2fPl233XabPv/8c73xxhu67rrrJEm/+93vlJycrDVr1mj16tU688yGF4lfv369Zs2apSVLlig/P18ul0svvfSS8vPztX37dn3xxRdas2aNrrnmmtZ78i2sVZatAQAAAAAAtKaEhATl5eVp8eLF+vjjj3XZZZfpgQcekCT96Ec/qn9/2223SZLmz5+vdevW1d+/vLxce/fu1fz58/Xqq6/W11NTUxuM8+GHHyovL09Dhw6VJFVXV6tjx44699xztWnTJt18882aMGGCxo0b5+jzdRLhEQAAAAAACEsul0tjxozRmDFjNHDgQD333HOSGl5xbP+/A4GAli1bptjY2AaPYa095BXKrLW66qqr9Pvf/77RsVWrVum9997Tk08+qdmzZ+uf//xnSzytVseyNQAAAAAAEHY2bNigjRs31t/Oz89Xz549JUmzZs2qf3/qqadKqlvm9sQTTzQ4v6l6SUlJg3HGjh2r119/Xbt375YkFRcXa8uWLSosLFQgENBFF12k3/3ud1qxYoUDz7J1MPMIAAAAAACEnYqKCt18880qLS1VZGSk+vTpo6efflrz5s1TTU2Nhg8frkAgoFdeeUWS9Pjjj+umm25SVlaWfD6fRo0apaeeekq/+c1vdNNNN2nAgAFyuVy65557dOGFF9aP069fP91///0aN26cAoGA3G63nnzyScXGxuqaa65RIBCQpCZnJrUXxlob6h6OSE5Ojs3NzQ11GwAAAAAA4BDWr1+vvn37hrqNRjIzM5Wbm6uMjIxQtxIyTb02xpg8a21OU+ezbA0AAAAAAABBsWwNAAAAAAAcMzZv3hzqFtodZh4BAAAAAAAgKMIjAAAAAAAABEV4BAAAAAAAgKDY8wgAgDamssanoooaLd9crD4dE9QjLU5p8dGhbgsAAADHKGYeAQDQhlhr9fnmYo354wLd/tpqXfDkUs18e71Kq2pD3RoAAEC7k5CQEPTYiBEjHBv3//7v/xx77FAgPAIAoA0prKjVvW+tU8B+V3tjxXZV1vhD1xQAAEAY8fvrfq5aunSpY2MQHgEAAMdYa1VW7W1Ur/ERHgEAAHxfCxYs0BlnnKHLL79cAwcOlPTdrKSCggKNGjVK2dnZGjBggBYvXtzo/mvXrtWwYcOUnZ2trKwsbdy4UZL04osv1tdvuOEG+f1+/fKXv1R1dbWys7N1xRVXSJIefvhhDRgwQAMGDNCjjz4qSaqsrNSECRM0aNAgDRgwQLNmzZIk3XfffRo6dKgGDBig66+/XtbaRv20NvY8AgCgDUmOdevyYcfpiY//W1/rlRGvxBh3CLsCAABw3psrt+uh9zZoR2m1uqbE6o7xJ+mCwd1a7PGXL1+uL774Qr169WpQf/nllzV+/Hj9+te/lt/vV1VVVaP7PvXUU5o+fbquuOIK1dbWyu/3a/369Zo1a5aWLFkit9utG2+8US+99JIeeOABPfHEE8rPz5ck5eXl6ZlnntFnn30ma62GDx+u0aNHa9OmTeratavefvttSVJZWZkkadq0afrtb38rSZo8ebLmzZunc889t8U+Dt8H4REAAG1ItNulKSN7qWtKrOau2qG+nZN0w+jj1SGRDbMBAED4enPldt31rzWq9tbNtt5eWq27/rVGklosQBo2bFij4EiShg4dqilTpsjr9eqCCy5QdnZ2o3NOPfVUzZw5U9u2bdOFF16oE044QR9++KHy8vI0dOhQSVJ1dbU6duzY6L6ffPKJJk6cqPj4eEnShRdeqMWLF+vss8/W7bffrjvvvFM//OEPdfrpp0uSPv74Yz344IOqqqpScXGx+vfvH/LwiGVrAAC0MWnx0Zo0tIf+35U5+uU5J6tzckyoWwIAAHDUQ+9tqA+O9qv2+vXQextabIz94c3BRo0apUWLFqlbt26aPHmynn/+ec2ZM0fZ2dnKzs5Wbm6uLr/8cs2dO1exsbEaP368PvroI1lrddVVVyk/P1/5+fnasGGDZsyY0ejxgy07O/HEE5WXl6eBAwfqrrvu0n333SePx6Mbb7xRr7/+utasWaOpU6fK4/G02Mfg+yI8AgCgDYqIMEqOcys60hXqVgAAABy3o7T6iOotacuWLerYsaOmTp2qa6+9VitWrNDEiRPrQ6GcnBxt2rRJvXv31i233KLzzjtPq1ev1tixY/X6669r9+7dkqTi4mJt2bJFkuR2u+X11u1jOWrUKL355puqqqpSZWWl5syZo9NPP107duxQXFycrrzySt1+++1asWJFfVCUkZGhiooKvf76644//+Zg2RoAAAAAAAiprimx2t5EUNQ1JdbxsRcsWKCHHnpIbrdbCQkJev755xudM2vWLL344otyu93q3Lmzfvvb3yotLU3333+/xo0bp0AgILfbrSeffFI9e/bU9ddfr6ysLA0ZMkQvvfSSrr76ag0bNkySdN1112nw4MF67733dMcddygiIkJut1t//etflZKSoqlTp2rgwIHKzMysXxIXaqYt7Np9JHJycmxubm6o2wAAAAAAAIewfv169e3bt1nnHrznkSTFul36/YUDW3TTbNRp6rUxxuRZa3OaOp+ZRwAAAAAAIKT2B0ROXm0N3x/hEQAAAAAACLkLBncjLGqj2DAbAAAAAAAAQREeAQAAAAAAICjCIwAAAAAAAARFeAQAAAAAAICgCI8AAAAAAEBYSkhICHpsxIgRrdhJ08455xyVlpYe8f1mzJihP/7xjw501DSutgYAAAAAAI4Zfr9fLpdLS5cubZXxfD6fIiObjl/eeeedkPfQHMw8AgAAAAAAYW3BggU644wzdPnll2vgwIGSvpuVVFBQoFGjRik7O1sDBgzQ4sWLG91/+PDhWrt2bf3tMWPGKC8vT5WVlZoyZYqGDh2qwYMH69///rck6dlnn9Ull1yic889V+PGjQs6RmZmpgoLCyVJzz//vLKysjRo0CBNnjxZkrRlyxaNHTtWWVlZGjt2rLZu3dqot/z8fP3gBz9QVlaWJk6cqJKSkvoef/WrX2n06NF67LHHjurjR3gEAAAAAABCb/Vs6ZEB0oyUuverZ7fowy9fvlwzZ87UunXrGtRffvlljR8/Xvn5+Vq1apWys7Mb3XfSpEmaPbuun4KCAu3YsUOnnHKKZs6cqTPPPFOff/65Pv74Y91xxx2qrKyUJC1btkzPPfecPvroo8OOsXbtWs2cOVMfffSRVq1aVR/2TJs2TT/+8Y+1evVqXXHFFbrlllsa9fbjH/9Yf/jDH7R69WoNHDhQ9957b/2x0tJSLVy4UD//+c+P6mNHeAQAAAAAAEJr9WzprVuksm8l2br3b93SogHSsGHD1KtXr0b1oUOH6plnntGMGTO0Zs0aJSYmNjrn0ksv1WuvvSZJmj17ti655BJJ0vvvv68HHnhA2dnZGjNmjDweT/3soLPOOktpaWnNGuOjjz7SxRdfrIyMDEmqv9+yZct0+eWXS5ImT56sTz75pMH9ysrKVFpaqtGjR0uSrrrqKi1atKj++GWXXXaEH6WmER4BAAAAAIDQ+vA+yVvdsOatrqu3kPj4+Cbro0aN0qJFi9StWzdNnjxZzz//vObMmaPs7GxlZ2crNzdX3bp1U3p6ulavXq1Zs2Zp0qRJkiRrrd544w3l5+crPz9fW7duVd++fRuN19QYB7LWyhhz2OfQnHOa85yPFOERAAAAAAAIrbJtR1ZvQVu2bFHHjh01depUXXvttVqxYoUmTpxYHwjl5ORIqlu69uCDD6qsrKx+36Tx48frz3/+s6y1kqSVK1c2e4wDjR07VrNnz1ZRUZEkqbi4WFLdFeFeffVVSdJLL72kkSNHNrhfcnKyUlNT6/dQeuGFF+pnIbUkrrYGAAAAAABCK7n7viVrTdQdtmDBAj300ENyu91KSEhoNCtov4svvljTp0/X3XffXV+7++67deuttyorK0vWWmVmZmrevHlHPEb//v3161//WqNHj5bL5dLgwYP17LPP6vHHH9eUKVP00EMPqUOHDnrmmWcaPfZzzz2nn/zkJ6qqqlLv3r2bPOdomf3pWHuRk5Njc3NzQ90GAAAAAAA4hPXr19cv4Tqs/XseHbh0zR0rnfu4lHWpMw0ew5p6bYwxedbanKbOZ9kaAAAAAAAIraxL64Ki5OMkmbr3BEdtBsvWAAAAAABA6GVdSljURjHzCAAAAAAAAEERHgEAAAAAACAowiMAAAAAAAAERXgEAAAAAACAoAiPAAAAAABAWEpISAh6bMSIEUf9+HPnztUDDzxwxPdrztjXXXed1q1b933aanHGWhvqHo5ITk6Ozc3NDXUbAAAAAADgENavX6++ffuGtIeEhARVVFQ0qPn9frlcLkfH9fl8ioxsuxe4b+q1McbkWWtzmjqfmUcAAAAAACCsLViwQGeccYYuv/xyDRw4UNJ3s5IKCgo0atQoZWdna8CAAVq8eHGj+w8fPlxr166tvz1mzBjl5eXp2Wef1bRp0yRJV199tX72s5/pjDPO0J133qk9e/borLPO0pAhQ3TDDTeoZ8+eKiwsbDD2ggULNGbMGF188cU6+eSTdcUVV2j/JJ8xY8Zo/+SZd999V0OGDNGgQYM0duxYSdLy5cs1YsQIDR48WCNGjNCGDRuc+NBJktpuDAYAAAAAAI4Zb296W4+teEw7K3eqc3xnTR8yXRN6T2ixx1++fLm++OIL9erVq0H95Zdf1vjx4/XrX/9afr9fVVVVje47adIkzZ49W/fee68KCgq0Y8cOnXLKKVqzZk2D87766ivNnz9fLpdL06ZN05lnnqm77rpL7777rp5++ukm+1q5cqXWrl2rrl276rTTTtOSJUs0cuTI+uN79uzR1KlTtWjRIvXq1UvFxcWSpJNPPlmLFi1SZGSk5s+fr1/96ld64403jvbD1CTCIwAAAAAAEFJvb3pbM5bOkMfvkSQVVBZoxtIZktRiAdKwYcMaBUeSNHToUE2ZMkVer1cXXHCBsrOzG51z6aWX6qyzztK9996r2bNn65JLLmlyjEsuuaR+Sdwnn3yiOXPmSJLOPvtspaamBu2re/fukqTs7Gxt3ry5QXj06aefatSoUfW9p6WlSZLKysp01VVXaePGjTLGyOv1NvdDccRYtgYAAAAAAELqsRWP1QdH+3n8Hj224rEWGyM+Pr7J+qhRo7Ro0SJ169ZNkydP1vPPP685c+YoOztb2dnZys3NVbdu3ZSenq7Vq1dr1qxZmjRp0mHHaO4e09HR0fX/drlc8vl8DY5ba2WMaXS/u+++W2eccYa++OILvfXWW/J4PI3OaSmERwAAAAAAIKR2Vu48onpL2rJlizp27KipU6fq2muv1YoVKzRx4kTl5+crPz9fOTl1e0hPmjRJDz74oMrKyur3TTqUkSNHavbs2ZKk999/XyUlJd+rv1NPPVULFy7UN998I0n1y9bKysrUrVs3SdKzzz77vR67uQiPAAAAAABASHWO73xE9Za0YMECZWdna/DgwXrjjTc0ffr0Js+7+OKL9eqrr+rSSy9t1uPec889ev/99zVkyBD95z//UZcuXZSYmHjE/XXo0EFPP/20LrzwQg0aNEiXXXaZJOkXv/iF7rrrLp122mny+/1H/LhHwjR3GlVbkZOTY/fvNg4AAAAAANqmpi4HH8zBex5JUowrRjNGzGjRTbNbU01NjVwulyIjI7Vs2TL99Kc/VX5+fqjbktT0a2OMybPW5jR1PhtmAwAAAACAkNofEDl5tbXWtnXrVl166aUKBAKKiorS3/72t1C39L0RHgEA2p3iylptLqrU+h3l+kHvdHVMilZijDvUbQEAAOAoTOg9oV2HRQc74YQTtHLlylC30SIIjwAA7UpZda0efPdLvfr5t/W1P/9osM4Z0FkuF1v5AQAAAC2Nn7IBAO1KZY2/QXAkSb+bt07FVbUh6ggAAADBtLd9lo8F3+c1ITwCALQrPn+gUW2vxyfJtH4zAAAACComJkZFRUUESG2ItVZFRUWKiYk5ovuxbA0A0K7ER0eqf9ckrd1RXl+7cngPJUTzLQ0AAKAt6d69u7Zt26Y9e/aEuhUcICYmRt27dz+i+/CTNgCgXUlPiNYzVw/V859uUf7WUk3I6qLx/TsrNsoV6tYAAABwALfbrV69eoW6DbQAwiMAQLvTMSlG08eeII/Xr4ToSBnDkjUAAADAKYRHAIB2ye2KkJurqwEAAACO46duAAAAAAAABEV4BAAAAAAAgKAIjwAAAAAAABAU4REAAAAAAACCIjwCAAAAAABAUIRHAAAAAAAACIrwCAAAAAAAAEERHgEAAAAAACAowiMAAAAAAAAERXgEAAAAAACAoAiPAAAAAAAAEBThEQAAAAAAAIKKDHUDAHAsqPH5VVbtlSSlxEYpKpLsHgAAAED7QHgEAA4rqazVq59v1V8X/FcREUbTx56giYO7KSUuKtStAQAAAMBh8advAHDYF9vL9Id3N6jc41NplVf3vrVOX++uCHVbAAAAANAshEcA4CBrreau2tGo/s6aghB0AwAAAABHjvAIABxkjNHQXmmN6jmZjWsAAAAA0BYRHgGAw8ae3FEj+6Q3uD28iUAJAAAAANoiNswGAIelJ0Trzz8aospan4yM4qJcSo1ns2wAAAAA7QPhEQC0gtT4KAIjAAAAAO0Sy9YAAAAAAAAQFOERAAAAAAAAgiI8AgAAAAAAQFCERwAAAAAAAAiK8AgAAAAAAABBER4BAAAAAAAgKMIjAAAAAAAABEV4BAAAAAAAgKAIjwAAAAAAABAU4REAAAAAAACCIjwCAAAAAABAUIRHAAAAAAAACMrx8MgY4zLGrDTGzGviWLQxZpYx5mtjzGfGmEyn+wEAAAAAAEDztcbMo+mS1gc5dq2kEmttH0mPSPpDK/QDAAAO4PH69W1xlZ5bulkfrNulwr01oW4JAAAAbUikkw9ujOkuaYKkmZJ+1sQp50uase/fr0t6whhjrLXWyb4AAMB3vt5doYl/WSKvv+7bb/+uSXpuyjBlJESHuDMAAAC0BU7PPHpU0i8kBYIc7ybpW0my1voklUlKd7gnAACwT1m1V39498v64EiS1u4o15aiyhB2BQAAgLbEsfDIGPNDSbuttXmHOq2JWqNZR8aY640xucaY3D179rRYjwAAHOsCAavKGl+jelWtPwTdAAAAoC1ycubRaZLOM8ZslvSqpDONMS8edM42ScdJkjEmUlKypOKDH8ha+7S1Nsdam9OhQwcHWwYA4NiSGh+lG0Yf36CWkRClkzolhqgjAAAAtDWOhUfW2rustd2ttZmSJkn6yFp75UGnzZV01b5/X7zvHPY7AgCgFf2gV7peum64xvXrpGtOy9TcaSPVIZH9jgAAAFDH0Q2zm2KMuU9SrrV2rqR/SHrBGPO16mYcTWrtfgAAONYlx7l1Wp8MDemRosiICLkjW+NirAAAAGgvWiU8stYukLRg379/e0DdI+mS1ugBAAAcWmxUq/9NCQAAAO0Af1oEAAAAAABAUIRHAAAAAAAACIrwCAAAAAAAAEERHgEAAAAAACAowiMAAAAAAAAERXgEAAAAAACAoAiPAAAAAAAAEBThEQAAAAAAAIIiPAIAAAAAAEBQhEcAAAAAAAAIivAIAAAAAAAAQREeAQAAAAAAIKjIUDcAAGj//P6Adu2tkZEUFRmh9IToULcEAAAAoIUQHgEAjkpZVa3ytpToN29+oV17azSuXyfdc25/dU6OCXVrAAAAAFoAy9YAAEelosan61/I044yj/wBq/98sVNPfvy1KjzeULcGAAAAoAUQHgEAjspXuyrkC9gGtU++LlRZNeERAAAAEA4IjwAARyUzI65RrV+XRMVFsTIaAAAACAeERwCAo5IY7dYd40+S22UkScd3iNcv/7evUuOjQtwZAAAAgJbAn4UBAEclIzFalw/voQuyu6rGF1Cs26UuKbGhbgsAAABACyE8AgActdS4KKXGMdMIAAAACEcsWwMAAAAAAEBQhEcAAAAAAAAIivAIAAAAAAAAQREeAQAAAAAAICjCIwAAAAAAAARFeAQAAAAAAICgCI8AAAAAAAAQFOERAAAAAAAAgiI8AgAAAAAAQFCERwAAAAAAAAiK8AgAAAAAAABBER4BAAAAAAAgKMIjAAAAAAAABBUZ6gYAoLWVVtWqtMqrt9cUqENCtE4/MUNdkmND3RZQr7zaq4Iyj+av36V+XZOU1S1Z6QnRoW4LAACgWYo9xVpftF7ritZpVPdR6pLQRUlRSaFuq8Xsrd2rgsoCLfx2ofql91PftL5Ki00LdVuOIjwCcMzZXlqtiU8uVa0/IEnqlRGvl6cOJ0BCm+APWC3auEfTXl5ZXxt7ckc9dMkgpcVHhbAzAACAwyv1lOr+T+/XB1s+kCQ9vvJxzTxtpib0niBXhCvE3R09f8CvRdsW6ZeLf1lfG9tjrGaMmKGU6JQQduYslq0BOKYUVdTo8Q831gdHkvRNYaXWbCsLYVfAd4ora/XAf75sUPvwy92qrPGFqCMAAIDmq/JV1QdH+z228jGV1JSEqKOWVVJTokfyHmlQ+3Drh6ryVoWoo9ZBeATgmBIIWHm8gUb1Kq8/BN0AjVlZ1TTxOeoP2BB0AwAAcGT8tvHP1R6fRwqjH2Vq/DWNak0973BCeATgmNIhKUZTR/VuUEuNc2tYZnivUUb7kRIbpetO79Wg1q9LkhJjWGkOAADavnh3vAZkDGhQm9xvshKjEkPUUctKikrS5H6TG9T6pfdTfGR8iDpqHcba9hX/5eTk2Nzc3FC3AaAd213u0ZbiKj2/dLPSE6I1ZWQvdUmMltvd/tdgIzyUVNbq883F+tfK7crqlqxLco5Th0Q2zAYAAO1DYXWh5v53rtbsWaMJvSfolE6nKDUmNdRttZhST6nyduVp3qZ5GpAxQOf3OV8ZsRmhbuuoGWPyrLU5TR4jPAJwrKqoqZXLRCg2ihkdaJs8Xr/crgi5IkyoWwEAADgiARuQ1+9VdGT4/gGsxlcjt8utCBMei7oOFR7xGxOAY1ZCNFeuQtsWw2w4AADQTkWYiLAOjiSF/fM7UHjEYwAAAAAAAHAE4REAAAAAAACCIjwCAAAAAABAUIRHAAAAAAAACIrwCAAAAAAAAEERHgEAAAAAACAowiMAAAAAAAAERXgEAAAAAACAoAiPAAAAAAAAEBThEQAAAAAAAIIiPAIAAAAAAEBQhEcAAAAAAAAIKjLUDQBAKOz1eFVV65eRlBIXpajI8MrSa30BlVbVykpKiI5UfLSzX+79/oCKKuvGi3W7lBTrdnQ8AAAAAK2H8AjAMaeookYz316vf6/aocSYSP1mQl+N69c5bAKPsupazc3foYfe26Bqr18Xn9Jdd4w7SWkJ0Y6MV1Xj07JNRfrlv9aosKJGY0/uqN9fmKUOic6MBwAAAKB1hdef2gHgMHz+gF7L26Z/rdwuf8CqtMqr219brcKKmlC31mIKyjy6+99rVe7xyeu3emX5t3rni50KBKwj45VWe3X9C3nas7dG1krz1+/Wnz/aqGqv35HxAAAAALQuwiMAx5TKGp8+XL+rUX3l1tIQdOOMTzcVNap9sG6Xqrw+R8b7prBS/oOCqUVf7VGFx+vIeAAAAABaF+ERgGNKXFSkcnqmNqr365oUgm6cMah7SqPa0Mw0xUa6HBmvR1pco1r2cSmKi2JlNAAAABAOCI8AHFPckRGaMrKXhvSoC5AiI4ymndFHXZJjQtxZy8lMj9e1I3N9izIAACAASURBVHvJFWEkST/onaZJQ4+Ty+XMl/zkWLdmnNtf0fs2HT+pU6LuPPtkxzfpBgAAANA6jLXO7IHhlJycHJubmxvqNgC0c8UVNary+hUZYZQQE6mE6PDYLHu/vR6vKmp8CgSsYqMilRYf5eh4VbU+7a32qdYfUGyUSxkObc4NAAAAwBnGmDxrbU5Tx/izMIBjUlpCtNJC3YSDEmPcSoxpvUAsLiqSZWoAAABAmGLZGgAAAAAAAIIiPAIAAAAAAEBQhEcAAAAAAAAIivAIAAAAAAAAQREeAQAAAAAAICjCIwAAAAAAAARFeAQAAAAAAICgCI8AAAAAAAAQFOERAAAAAAAAgiI8AgAAAAAAQFCERwAAAAAAAAiK8AgAAAAAAABBER4BAAAAAAAgqMhQNwC0hD17Pfr4yz3aVe7Redld1TExWrFRfHq3F3s9Xu0o9ejtNTt0UqckDe+dpoyE6FC3BQAAAEl7a/eqoLJAH2z+QCemnqghnYYoPTY91G0BaEX8do12b8/eGl381DJtKaqSJD324UbNnXaa+nVNDnFnaA5rrT7dVKypz+fW107pmaqnJ5+idAIkAACAkArYgD4r+Ey3LbitvnZKp1P0yJhHlBqTGsLOALQmlq2h3Vu3o6w+OJIkX8Dq4Q++UkWNN4RdobmKKmv10HtfNqjlbSlRUWVtiDoCAADAfiWeEj2+4vEGtbxdeSqtKQ1RRwBCgfAI7V6tP9C45gvI2hA0gyNmreT1N36x/AFeQAAAgFCzsvIGGv9RNmAb/wwOIHwRHqHdG9Q9RRkJUQ1q0848QYkx7hB1hCORFh+ln445vkGtT8cEdWDJGgAAQMilRqdqysApDWonpJyglOiUEHUEIBSMbWfTM3Jycmxubu7hT8Qxw1qrXeUevfDpFu0q9+jqEb2UmR6nBMKjdqO0qlbrCso16/Nv1bdLki4a0k0dEmNC3RYAAAAkldWUaX3Res35eo5OTjtZ5x5/rjJiM0LdFoAWZozJs9bmNHmM8AjhIhCwClirSBcT6torrz+gyAgjY0yoWwEAAMBBfAGfXMbFz2pAmDpUeMTV1hA2IiKMIsQ3svbMTfAHAADQZkVG8OsjcKziNzUAAAAAAAAERXgEAAAAAACAoAiPAAAAAAAAEBThEQAAAAAAAIIiPAIAAAAAAEBQhEcAAAAAAAAIivAIAAAAAAAAQREeAQAAAAAAICjCIwAAAAAAAARFeAQAAAAAAICgCI8AAAAAAAAQFOERAAAAAAAAgop06oGNMTGSFkmK3jfO69baew4652pJD0navq/0hLX27071BKDt2lXukc8fkDFG6fFRina7HB2vsKJGNd6AZKSU2EjFR7sdHa+yxqeKGp8kKSkmUrFRjn35PSYEAlZFlTXyBayiIyOUFh8d6pYAAACAsOXkby81ks601lYYY9ySPjHG/Mda++lB582y1k5zsA8AbdyO0mr9fPYqLdtUpIyEKP3+woEa3itNSbFRjoy3q9yje+eu1btrdyo+KlK3jz9JEwZ2UUaiMwFEcWWtnvxoo174dKuMka4d2UvXnd5bafHOPL9w5/X7tWZbuaa9vEI7yjzK6p6sv1wxRN1T40LdGgAAABCWHFu2ZutU7Lvp3vdmnRoPQPtUUlmr/3tnvZZtKpIkFVbU6saXVmivx+/IeLU+v15ZvlXvfLFTASvtrfHpnrlrVVxZ68h4kpS3pVj/WLJZtf6AanwB/WXBf7W+oNyx8cJdSaVXVz+zXDvKPJKk1dvKdPtrq1RS5dxrCAAAABzLHN3zyBjjMsbkS9ot6QNr7WdNnHaRMWa1MeZ1Y8xxTvYDoO2prPVp+TfFDWpev9WO0mpHxiut8mrJ14WN6rlbips4++hZa/Xe2l2N6vPXN66heSprfSr3+BrUln9TLK8/EKKOAAAAgPDmaHhkrfVba7MldZc0zBgz4KBT3pKUaa3NkjRf0nNNPY4x5npjTK4xJnfPnj1OtgyglcW6Xco+LqVBLcJIXZJjHBkvMSZSQ3qkNqoP6p7SxNlHzxijUSdkNKqP7NO4huaJi4pUXFTDPbGyuqcoMsKEqCMAAAAgvLXK1dastaWSFkg6+6B6kbW2Zt/Nv0k6Jcj9n7bW5lhrczp06OBorwBaV3pCtO7+YT+d3DlRkhQf5dIDF2UpPtqZLdlioyJ1zWm9dGrvdElSlCtCN5/ZRx0c2u9Ikkae0EEXZHeVMXXB2GVDu2vwcY0DLDRPSpxbf71yiJJj6zY575kep0cuy2bTbAAAAMAhxlpntiEyxnSQ5LXWlhpjYiW9L+kP1tp5B5zTxVpbsO/fEyXdaa39waEeNycnx+bm5jrSM4DQKSitVq0/oEhXhJJjIpUQ4+zVz3aVeVTj98tljOKiI5Ua5+zm1eXVXlXW+CQjxUdFKinW2ecX7mp9fpVUeVXrCyjGHaGMhGgZw8wjAAAA4PsyxuRZa3OaOubk1da6SHrOGONS3Qyn2dbaecaY+yTlWmvnSrrFGHOeJJ+kYklXO9gPgDasS0psq47XyaFlccEkxboJjFpQVKRLnZJchz8RAAAAwFFzbOaRU5h5BAAAAAAA0LIONfOoVfY8AgAAAAAAQPtEeAQAAAAAAICgCI8AAAAAAAAQFOERAAAAAAAAgiI8AgAAAAAAQFCERwAAAAAAAAiK8AgAAAAAAABBER4BAAAAAAAgKMIjAAAAAAAABEV4BAAAAAAAgKAIjwAAAAAAABAU4REAAAAAAACCigx1A0BL2F3u0btrd2pXuUcXDemuzkkxiosOn0/vXeUe5W4u1uebSzS2b0ed1ClRHZNiQt1WiymsqNH2kmrNXbVdJ3RM1Bknd1QnB59fVa1PO8s8emPFNnVMjNH/Dujs6MfT6w9od3mN5qzcpghjNHFwN3VMjJbLFT75/c4yjz5Yt1Nbiqo0cXA3dUmOUVpCdKjbAuoEAlLFTmnN65K3Shr0IymxsxQZPp+jRdVF+mznZ1pXuE5n9zpbPRJ7KCk6ybHxij3FWlu4VssKlun0bqerb1pfpcSkODYeAAAILWOtDXUPRyQnJ8fm5uaGug20IXv2ejTxL0u1raRakuSKMHrzxhEa2D08fojds9ej381bp7mrCuprt4zto+tP762EGHcIO2sZgUBAb6/ZqZtfWVlfy+qerKcnn6LOybGOjLl2e5nOe3KJ/IG6r3/dUmL15k0j1CHRmQBpW0mVxj2ySFW1fklSUkyk3rt1lLqkOPP8WtvOsmpd9c/PtWHX3vraP67K0di+nULYFXCA8h3SU6dJVcV1tyNjpJ8uldKPD21fLaTEU6KfLfiZcnd99/PRzNNmakLvCXJFuFp8vIraCj2c97Be++q1+tq1A67VDVk3KNYdHl/XAAA4Fhlj8qy1OU0dC58/e+OY9cX28vrgSJL8AauHP9ioCo83hF21HI83oLdWFzSo/X3xNyr3+ELUUcvaWV6jxz/c2KC2eluZSiqdef0qarx69MOv6oMjSdpeWq3V28ocGU+SXvx0S31wJEnlHp/mrNzu2HitbUepp0FwJEmPf7hRO8uqg9wDaGVfvvNdcCRJPo+07EnJHx5fRytqKxoER5L0ZP6TKqkpcWS8Sm+l3tj4RoPaC+te0F7v3iD3AAAA7R3hEdo9fxOz5wLWqn3NqTu0g5/igcFHe2dV93odrKnXtaUG9PqbGM/Bj6mvifF8gYBj47W2YK9fO5vYinAW8DdR80lh8p0ioMZfT/y2iefcgg6eud5UDwAAIHwQHqHdy+qWrI6J3+1bYUzdsq7EMFjSJUnRkREa16/h8p8fn5qphDDZ06lzYrRuGNW7Qe2kTonKSIhyZLyEGLemjz1BxnxX65AYrezjnFvmOPnUnoqO/O7LbazbpYuGHOfYeK2tW2qsemXEN6j9dEyfsFmWhzDQ94fSgfv/uNzSiGl178NAojtRAzMGNqhNzZqqlGhnvq7FRsZqQu8JDWqXnnip4t3xQe4BAADaO/Y8QrtnrdXu8hrNzvtWO0s9mnxqT3VPiwubcEWq2zB7wYbdWv5Nscb27aRTeqY6uqF0a9uz16Ovd1fqXyu2qU/HBJ2f3dWx/Y4kqbLGp29LqvTC0i3qlBytS3N6qFNStMyBiVILqvH6tbPco+eXbZYrIkI//kFPdUqOltvV8nuRhEpBWbXmrNiuzUWVuiTnOPVKj1dGYvhsRox2zu+T9hZIuc9I3kpp2PVSUlcpjPbnKaou0vwt87WmcI3O73O+Tkw5UckxyY6NV+wp1qc7PtWSHUt05nFnakinIUqNSXVsPAAA4LxD7XlEeISwEghYRUQ4EwC0BX5/IKyu0HWw1n5+rf35sv/rrVMhVVsQ7p+jCAPWSmH8fzBgA4owrfh1tJXHAwAAzjlUeBQ+UzMAKayDI0lh/0t5az+/1v58CefQaL9w/xxFGAjz/4etHeQQHAEAcGzgOz4AAAAAAACCIjwCAAAAAABAUM1atmaM6SXpZkmZB97HWnueM20BAAAAAACgLWjunkdvSvqHpLckBZxrBwAAAAAAAG1Jc8Mjj7X2cUc7AQAAAAAAQJvT3PDoMWPMPZLel1Szv2itXeFIVwAAAAAAAGgTmhseDZQ0WdKZ+m7Zmt13GwAAAAAAAGGqueHRREm9rbW1TjYDAAAAAACAtiWimeetkpTiZCMAAAAAAABoe5o786iTpC+NMZ+r4Z5H5znSFQAAAAAAANqE5oZH9zjaBQAAAAAAANqkQ4ZHxpg+kjpZaxceVB8labuTjQEAAAAAACD0Djfz6FFJv2qiXrXv2Lkt3hGAY1JxZa08Xr8iI4xS491yu1yOjldW5VWV16cIY5QcG6kYd3MnYgIAAn6fiqv3yBvwyR0RqfS4TjIRzd1KE21BqadU1b5qSVJsZKxSYtjeFAAQ3OF+W8q01q4+uGitzTXGZDrSEYBjzs6yat340kqt2FqilDi3HrwoSyP7ZCgu2plAp7CiRnf9a43mr9+lWLdLd4w/SRcO6a7kWLcj4wFAOPH7vPqqZINuXfhz7ajcoZ5JPfXY6Id1fNqJoW4NzbS7arf+vubveu2r1yQrXdDnAt2YfaM6xHUIdWsAgDbqcH8iijnEsdiWbATAsanC49X9b6/Xiq0lkqTSKq9ufGmFyj1eR8bz+QN6+bOt+mDdLlkrVdX6de9b67S73OPIeAAQboo9hbp5wa3aUblDkrSlfItuW3i7iioKQtwZmmtt4Vq98uUr8gV88lmfXt/4ulbsXhHqtgAAbdjhwqPPjTFTDy4aY66VlOdMSwCOJVW1fi3/prhBzRewKihzJsypqPFp8cY9jeqrt5U5Mh4AhJvaQK12Ve1qUPum/Bt5rT9EHeFILdmxpFHtk+2fhKATAEB7cbjw6FZJ1xhjFhhj/rTvbaGk6yRNd749AOEuLsqlnMzUBjVXhFHnpENNfPz+4qMjNeL4jEb1gd2SHRkPAMJNVESUOsQ2XN7UI7GHIg17HrUXp3Y5tVk1AAD2O+R3eWvtLmvtCEn3Stq87+1ea+2p1tqdzrcHINwlxLh194R+9eFNUkykHp+UrSSH9h9yuyI0+Qc9NfrEugApOjJCd/3vyerkUFgFAOEmLSZdfx7ziDrFdZIkdY3vqkdH/0npcZ1D3BmaK6tDli464SK5jEsRJkLnH3++hnYeGuq2AABtmLHWNu9EY1ySOumATbattVsd6iuonJwcm5ub29rDAnBYUUWNPL6A3BFGKXFRiop09i/YpVW1qqr1yxVhlBTjVmyUs1d3A4Bw4vd5VeIpVG3Aq6gIt9JiOyjCxVUr25Pi6mJ5/HVLxGNcMUqLTQtxRwCAUDPG5Flrc5o61qzv8saYmyXdI2mXpMC+spWU1SIdAjjmpSdEt+p4KXFRSolr1SEBIGy4It3KSOgS6jZwFAiLAABHorl/Ipou6SRrbZGTzQAAAAAAAKBtae66kG8lcSkiAAAAAACAY8whZx4ZY36275+bJC0wxrwtqWb/cWvtww72BgAAAAAAgBA73LK1xH3vt+57i9r3JtXteQQAAAAAAIAwdsjwyFp7ryQZYy6x1r524DFjzCVONgYAAAAAAIDQa+6eR3c1swYAAAAAAIAwcrg9j/5X0jmSuhljHj/gUJIkn5ONAQAAAAAAIPQOt+fRDkl5ks7b936/vZJuc6opAAAAAAAAtA2H2/NolaRVxpiXrLXeVuoJAAAAAAAAbcThlq2t0b6rqhljGh231mY50xYAAAAAAADagsMtW/vhvvc37Xv/wr73V0iqcqQjAAAAAAAAtBmHW7a2RZKMMadZa0874NAvjTFLJN3nZHMAAAAAAAAIrYhmnhdvjBm5/4YxZoSkeGdaAgAAAAAAQFtxuGVr+10r6Z/GmOR9t0slTXGmJbS06lqfdpbX6OXPtiolzq2LhnRXx8RoRUQ03seqvdpV7tG/87eroMyjy4f1ULeUWMVFN/fT+8jtLPPovbU79dWuvZo4uJt6psepQ2KMY+OFu/Jqr74prNTred+qb5ckjevXWRmJ0aFuC4BTfB6pfIeU95zkjpMGXykldpYiXKHuDG1UaeVufVWyUe9una9TOmTp1K6nKS2+o2Pj7a3dq2/3fqs5G+fo+JTj9T89/0cZsRmOjXcs2F21W29velt7qvbo4pMuVue4zopzxzk2XmF1oT7e+rG+KvlK5/c5Xz2SeigpKsmx8VRZKH2zUPpmsdTvfKnLICkuzbnxWll5Tbk2l2/W3P/OVd+0vhpz3Bilx6aHui0ArchYa5t/sjFJ++5T5lxLh5aTk2Nzc3NDNXy79NXOvTrn8cXyBepe6/T4KL0z/XR1SgqPsGP3Xo/Of2KJCso8kqQII/3rxhHKPi7VkfF2lnl03fOf64vt5fW1P10ySBdkd5XL1dzJfNgvELB6e02Bbn5lZX2tf9ckPTdlmDISCJCAsFS4UfrrCMlfW3c7NlX66TIpqUto+0KbVOut0ovrXtAj+U/U10Z3G6n7T52hlPhOjoy58NuFmvbRtPrbx6ccr3+M+we/LH9PhVWFuuzty7S7arckKcJE6JUJr6hfej9HxiuqLtINH9ygDSUb6mt/Gv0nndXzrCYvAnTUqkqkubdIX879rjbmV9Jp0yV3+/952x/w6z/f/Ed3fXJXfa1/en/9ZexflBYbPgEZAMkYk2etzWnq2CF/0zXGXLnv/c+MMT+TdJ2kaw+4jTbO4/XrLwu+rg+OJKmoslafbCwMYVcta822svrgSJICVnp0/kbt9XgdGa+kqrZBcCRJT378tXbtrXFkvHBXXFmrR+dvbFBbu6NcRRW1IeoIgKN8Xmnpn78LjiSpukT68u3Q9YQ2raymTH9f+1yD2sLtn6jK78z3iWJPsZ7Mf7JB7b+l/9XOqp2OjHcsWLVnVX1wJEkBG9BTq55SpbfSkfGKPEUNgiNJ+suqv6jYU+zIeKqtaBgcSdLSxyRPqTPjtbKSmhL9ddVfG9TWFq1VaU14PD8AzXO4dT379zVKdLoRAAAAAAAAtD2HW2MzW5Kstfc29dYK/eEoxbhdunFMH0UesL9RenyURp4QPuv2B3ZPVpfk76YERxjp1v85QYkxbkfGS42L0oBuDdfM33RGH3Vij57vJS0+Srf+zwkNav27Jik9ISpEHQFwVKRbGnGz5Drg/3hsqnTyhND1hDYtOTpZ1/W/qkFtdLeRinM58303LSZNN2Xf1KB2fMrx6hzX2ZHxjgWDOgxSx7jv9qhyGZd+Mugninc7c/2d9Jh0nZR6UoPajYNuVFqMQ0usohKkk89rWBsxXYpJcWa8VpYanaqfDvppg1r/9P5KiQ6P5wegeQ6555ExZrekPZKWSloiaam19qtW6q1J7Hl05PZvmP3Kvg2zLwzTDbPnrtqhgtJq/Wh4D3VLdnbD7F37NszewIbZLWL/htlvrNimvl2SdFbfTmyYDYQzn0cqL5Dynq37pSv7cjbMxiHt3zD7va3zNaSVN8zuk9JHY3uOZcPso3RsbJi9qO6t3wVSlyw2zAbQ7hxqz6PDbphtjDlR0ogD3jpI+lTSEmvtgy3c62ERHgEAAAAAALSsQ4VHh52asW+m0VeSnjXGHC/pHEnTJY2T1OrhEQAAAAAAAFrPIcMjY8z+2UanSjpO0ibVzTq6UtIKx7sDAAAAAABASB1u5tEnqguJHpb0prW2yvmWAAAAAAAA0FYcLjzqqu/2OvqJMSZSdWHSMknLrLWbHO4PAAAAAAAAIXTI8Mhau1PSv/a9yRgTJ2mKpHsl9ZLEZVEAAAAAAADC2OH2PEpW3X5H+2cfDZb0taS3JC1xvDsAAAAAAACE1OGWrX2tug2yl0r6naTl1tpqx7sCAAAAAABAm3C4ZWsdWqsRAAAAAAAAtD2HW7b2liQb7Li19rwW7wgAAAAAAABtxuGWrf2xVboAAAAAAABAm3S4ZWsLW6sRAAAAAAAAtD2Hm3kkSTLGnCDp95L6SYrZX7fW9naoLwAAAAAAALQBEc087xlJf5Xk+//s3Xl83WWd9//XlZyTPWmaNi1tgUIpFKjsEVkE2XUUcZxhc8FlZhxwUFAZ5zeO963j+LjH8Z4Z75lRVBiZURRZBgFxQREFRVE0LTsFy1KgpUv2fTs51++PE9qmyYEU881JTl/PxyOP5lznkM8n5Drfk/PO97q+wKnAtcA3k2pKkiRJkiRJs8OUzjwCKmOMPw0hhBjjc8DfhxDuBT6dYG/SlA0Mj9I9OMJoNlJVVkp9VVmhW5pWo6NZ2vqHGc5kKU+VsrCmjBBCgvVG2dozxPBoJF1SwoLqNBVlUz1cSJI0/doG2hgaHSJdkmZ+xXxSJb4u/SF6+1roy44AUF2Spqa6uC6y3D/US9dID6MxQzqkWFyzpNAtSdKcNtVX3cEQQgmwPoTwIWATsCi5tqSp6+of5sbmjfzrnU8ylMly8oEL+cL5R7KwtrzQrU2LkdEsD2/s5JJvraWlZ4jlC6q45r2vZeWimsRqPt3azweubea5tn4aa8r54juP4rBldVSXpxOrKUlSPs93P8+Hfvohnu1+loaKBv75Df/MkY1HUlZaXH8smikdfVu58sGvcPPTtxGJ/PH+Z3P50ZfRUL240K1Ni87+Vu7d/Gv+8f5/pHekl9ULVvOFU77A0pqlhW5NkuasqS5b+whQBVwGHANcBLw3qaak3bGtZ4h//OE6hjJZAH6xvpWv/3oDw2O357qOvmH+4hvNtPQMAfBcWz+XXreWtt6hROpt6hjg8hse4Lm2fgBaeoe45Ftr6OwfSaSeJEkvp2Owg0/c+wme7X4WgPbBdi772WV0DXUVuLO565GWh7nxqe8wGkfJxiy3PHM7a7b8rtBtTZv+7DD/+1f/m96RXgAea3uMf23+Vzr6WwvcmSTNXVMKj2KMv4sx9gLdwGUxxj+JMf4m2dakqXlk08RfHn/9dBt9w5kCdDP9BkZG6dgluHlyaw8j2ZhQxci6zT3jRjr7RxgYKY4wTpI0t2SyGR5ufXjcWN9IH/2Z/gJ1NPf9cvP9E8e2TBybqzb1bmI0jo4be6jlIQZGBwvUkSTNfVMKj0IITSGER4CHgUdCCA+FEI5JtjVpag7fu37C2EkHLqSmvDj2QqhMl7Kgevxp+YcuqSNdksyeRyEEVi+tGzfWUF1GZVlpIvUkSXo5qZIURzQeMW6sNl1LVaqqQB3NfScvPWHC2BuWTBybq5bVLKU0jP+95ahFRzlnJOkPMNVla/8F/FWMcb8Y437ApeSuwCYV3KLacj5zzmqqykoJAc44ZBHvft1y0qVTnd6zW0N1Gf/1vteydF4FAAc01nDlO49mQU0yezotra/k3y88avueSkvnVXDVRcfQUOV+R5KkmTe/Yj6fO+lzHDT/IAAWVS3iS6d/ifryiX880tSsXriad6+6kFRJilRIceGB53LU4qML3da0qSqp4PMn/RPzyucBueDoY8d8jPrKhgJ3JklzV4jxlZe+hBB+FWM88ZXGZkJTU1Nsbm6e6bKa5QZHRukaGCEbI1XpFPOKLOjIZiOtvUOMZCNlpSU0zsBm4Js6+hnNRkpLSlhYU0Z52jOPJEmF0z7QztDoEKnSFA3lDZSW+Lr0h+jrb6VvdBiA6tIyqqsWFrij6TUw3EfncBfZGEmFEq+2JklTEEJYE2Nsmuy+qa7r+W0I4SrgeiACFwD3hBCOBogxrp2WTqVXqSJdSkURhxslJYFFdRUzWnPZfE/tliTNHg2eNTKtqqsWUl3oJhJUWVZNZVkxf4eSNLOmGh4dOfbvp3cZP4FcmHTatHUkSZIkSZKkWWNK4VGM8dSkG5EkSZIkSdLsM9WrrS0OIVwTQrhj7PahIYQ/T7Y1SZIkSZIkFdpUL0f1deDHwNKx278HPpJEQ5IkSZIkSZo9phoeLYwx3gRkAWKMGWA0sa4kSZIkSZI0K0w1POoLISwgtzk2IYTjgK7EupIkSZIkSdKsMNWrrX0MuB04IITwK6ARODexriRJkiRJkjQrvOyZRyGE14YQ9ooxrgXeAPwdMATcCWycgf4kSZIkSZJUQK+0bO0qYHjs8xOATwJXAh3A1Qn2JUmSJEmSpFnglZatlcYY28c+vwC4Osb4HeA7IYQHk21NkiRJkiRJhfZKZx6VhhBeCphOB362031T3S9JkiRJkiRJc9QrBUDXAz8PIbQCA8C9ACGElXi1NUmSJEmSpKL3smcexRj/D3AF8HXg9THGuNN/9+GX+29DCBUhhN+GEB4KITwWQvjMJI8pDyHcGEJ4KoRwfwhhv1fzTcxV2Wx85QfN4XqafqOj2Rmt5xzVbsvO7BydcdnRGa5X3P8/YwG+vx2/ysyM7EzPGU2rTDYzswVn+DkRs9kZfx5mY3Ef12baTP//9Oc39zln9Gq94tKzGONvJhn7/RS+9hBwWoyxN4SQBn4ZQrhjl6/350BHjHFlCOFC4PPk9lYqat0DIzzT2sf19z/HisYa3n7UMhbVtA54kQAAIABJREFUVSRWr384w4udA1z76+eYV5nmncfuy6K6CkpLQmI1Nb22dg/ysye28bsN7ZxxyGKOWT6fxQnOmfa+YR54voMfPrKZEw5YyCmrGllQU55Yva6BEdZv7eHG5hc4dEkdZx++lMba5OopAT1b4eEbofX3cMz7YMFKqKwvdFfTp2cLbLgXnroL9j8FDjgVavdKrl5/O2x9FB66HpYdA4ecAzWLkqs3wwaHetgysI3rn7ieqtJKzj/4AhZVLqI0VZZIvUw2w7b+bdz05E0MZgZ5x8HvYHH1YipSyR1HW/q2cNv6W3ixfxvnH/in7FO9lJqqBYnV0/Ta1reNjb0bufWpW1let5y3rngri6sXJ1dwuA86X4Df/idULYCm90LNEih5pR0mXp2RkX62DrRwwxM3AJELV72DRZULKSurTqRejJFt/du4Zf0ttA60cuHBF7KsZhlV6apE6u0JOgY7eHDbg9z1/F0ct+Q4Tlx6Ig2VDYnV6xrq4qnOp7h1/a0cuuBQ3rjfG1lQ6TFtLmnpb+H7z3yfDd0bOO+g81heu5za8trE6rUNtHH3C3fzwLYHOHvF2Ryy4BDqy4vod8M9UJiJv8CFEKqAXwIfjDHev9P4j4G/jzH+emxvpS1AY3yZppqammJzc3PiPSfprse38hfX7vgeli+o4uZLTkjszfITm7t5yxd/yejYWR31VWl+/JGTEw0fNH22dQ/yv257lDsf37p97AMnreDDp62krjI97fUGhkf50t3rufLup7ePnXXoYv7vuYdTXzX9b+yy2ch3H9zER296aPvYqsW1XPeB17EwwcBK06h3G/z3m6Btx5zhgm/DIW8pXE/Tqb8NfvpZWPPfO8YOOx/e+H+SCXRGM9D8X3DHx3eM7f1aeMcNUL1w+usVwDMdv+dPv3cBmZg7q6M2Xcut59zM4pqlidTb0reFt3/37fSO9AKQKklxyzm3sP+8/ROp19q3hXfccRFb+rZsH7vmjK9y7LITE6mn6TU6Osqdz9/J3/zib7aP7Ve3H18762vJBUibH4ar3wAv/YW+agF88L7EQuoXu1/gj7/3pwxkBgAoLy3ntnO+w951yxOp19LfwnnfO4+2wTYAAoHr3nwdhzUelki9YjcwMsCXH/oyX3/s69vHzlx+Jp8+/tPMK5837fVGs6Pc/vTtfOq+T20fWzV/FVefeXWigZWmT+tAKxfdcREbezZuH7vy9Cs5ee+TE6nXMdjBx+75GM1bd7znveKYK3jXoe8iXTL97180fUIIa2KMTZPdl8yfM3YULh27Kts24Cc7B0djlgEvAMQYM+T2USrqCLutd4j/+Nn6cWPPtfWzsaM/kXqDI6NcefdT24MjgM7+Ee5d35pIPU2/oUx2XHAEcO2vN9A7lMyp9D2DI1zzy2fHjd35+Fb6hpJZetHWN8yX7n5q3NiTW3to7R1KpJ4S0PnC+OAI4Bf/F/qK5Dgz0g8PfHP82KM3Q2YwmXr9bfDLL4wf2/g7GOpOpt4MG8kM8vXHrt0eHAH0jPTwsw0/SazmT5//6fbgCHJnIn3jsW8ktiTpqfbfjwuOAL7yyNfo6tuWSD1Nr60DW7nmkWvGjW3o3sDmvs3JFBzuh1/8y47gCHLHgWfvTaYecNv6W7YHRwBDo0Pc+MSNidV7sOXB7cERQCRy1cNX0TfSl1jNYtYz0sO313173NhPnvvJuJ/pdOoc6uTqR64eN/Zkx5N0DnUmUk/Tb2PPxnHBEcBXH/oqHYMdidTrG+kbFxwBXPPoNXQNuW3yXJZoeBRjHI0xHgnsDRwbQnjNLg+ZbN3UhLOOQgh/GUJoDiE0t7S0JNHqjAkhUBomftthkrFpqQekSif+mF2yNrfsOj2S/vmVTDpHk6kVwuT1JhvTLBUmeSkpKWHyQ/xcFCZ+jyGQ6PdXUjp5H0UgECgNE7+/0km/5+kxWb1USO6isaUlE792aSglTPZc0awTCJPOx5Kkfn4hTP6cT/I5McnXTk3yPJkukz3fJnteamomm6Mh4deIyX6GSb1/0fSb7PhVEkoSmzeTzQ2f83PfjPwWE2PsBO4B3rTLXRuBfQDGlq3NA9on+e+vjjE2xRibGhsbE+42WQ3VZVxx1qpxb8QPWlzD3vMrE6lXni7l0lMPoGynAKmxtpwTDyjqE7yKSkW6hLcevmTc2F+ctD91Fcm88amrTHPpqSvHjb3tyKVUlyVTb0F1GVecddC4sSP2mceC6mT2PlEC5u0Niw4dP3bq/4LqIjnOpKvhtR8YP3bkuyGVzHGbqoVwyifGj+13EpTXJVNvhqVS5bx/9XspL92xLHV++XxO2ff0xGqetu9p4/ZZKC8t5z2r30NqkpBnOqyoP4B9a/fdfrsklHDp4RdTV1Ucyw6L3ZKaJVxy+CXjxg6afxCLqxJaspauhDf8DZTutJSjdgksPyGZesDbVr6dmnTN9ttVqSrOW3V+YvUOazyMvap3LMFLhRQfPPKDVKeT2WOp2NWW1fK+1e8bN/bWA95KVSqZPaTmV8zn0iMvHTd2xMIjElkip2Qsq1nGinkrtt8OBD581Iepr0hmD6KqVBWvX/b6cWMfPOKD7nk0xyW251EIoREYiTF2hhAqgTuBz8cYv7/TYy4FDosxXjK2YfafxBhf9pWrGPY86hkc4cXOAW59YBMrFtZw6sGLEt0ceHBklK3dg3xn7SbmVaY4+/ClLKot968Fc8jWrkHWPt/Bb59t57RDFrFqcW2im6x39A3z+609/OTxrbxuxQKO3rc+0Q2zuwdHeKG9n+8+8CIHL6nl5IMa3e9orundBuvvhNb1cPj5UL8vJLgJ44zr2ZLbk+Tpn8L+b4BlR+Xe3CVloBPan4ZHb83V2v9kqJ7bfzzZ2fBwHy2Dbdy+/jYq05X80YqzaaxspKQ0mTAnG7O09Ldwx7N3MJAZ4JyV59BY2UhZaXIhdWvfVu5+7i5e7NvMW1e+jb0qGqkqpk3ki1xLfwstAy384JkfsG/dvpyy9ynJbpg9MgA9m+HB63P7Ha3+Y6hZnNhpv5nMEK0DrXz/6duJMcvZK99GY8VCUukEN5Hvb+Gu5+6idbCVcw44h0VVi6hMKoTfA3QOdrK+cz33vHAPr93rtRzReATzK+YnVq97uJuNPRu549k7WNWwiuOXHO+G2XNM60ArP9/4c57vfp63rngrS2qWJBrgtg+007y1mYdbHubM/c5kv7r9DBzngJfb8yjJ8Ohw4BtAKbkznG6KMf5DCOEfgOYY4+0hhArgm8BR5M44ujDG+MzLfd1iCI8kSZIkSZJmk5cLjxJb8B9jfJhcKLTr+Kd2+nwQOC+pHiRJkiRJkvSHcedGSZIkSZIk5WV4JEmSJEmSpLwMjyRJkiRJkpSX4ZEkSZIkSZLyMjySJEmSJElSXoZHkiRJkiRJysvwSJIkSZIkSXkZHkmSJEmSJCkvwyNJkiRJkiTlZXgkSZIkSZKkvAyPJEmSJEmSlJfhkSRJkiRJkvJKFboBzYyO/mEGhkcpCVBTnqKmIl3oliRp7siOQl8rZAYgVQFVjVBammzN3m0wMgCpMqhsgFR5svWK3WA3DPdCzEJZNVTOT7becB8MduXmTroSqhcmWy8zCAMdkBnO1atZlGy5bIaOwQ6GRoeoKK1gfsV8SksSfE7ECH3bYGQw91yobMg9N4pJfzuM9EMogfI6KK8pdEdSQXUMdjCQGSBVkqImXUNVuqrQLUl7NMOjPUBr7xB//T8Pcc+TLaRKAn9+0v5ccvIBzK8usl+6JCkJ2SxsfQy+fT70bM69Kb/w27Dk6OQCpI4NcN250Lo+9ybyj78CK08Df3F+dfra4Oefh+av5cKcg98Kb/1/UN2YTL2BTnjgW/Czf4DMEOxzLJz/LahdnEy94X54+qdw21/BUDcsPAjedTPMX55IuUw2w+Ntj3PZzy6jbbCNxVWL+dLpX2LV/FWEEBKpSdvTuedEx7O54O9Pr4HlJ0K6Ipl6M62vBW65OPdzLEnBiZfD8R+CqoZCdyYVROtAK3/9879mzdY1pEvS/NWRf8V5B53HvPJ5hW5N2mO5bK3IjWYjt6zdyD1PtgCQyUau+vkzPNfeV+DOJGmO6G+FG9+dC44gd0bQDe+C/pZk6g10wO0fzgVHkAsDbn4/DHQlU29PsO1x+O1VueAI4Invwbrv585mSUJfC9z5yVxwBPDCb+GXX8idNZOEwa7cHBnqzt1u/T1877LcXEpAx2DH9uAIYGv/Vj56z0e33552fa1wywdywRHkvq+b3gODyXx/M250FNZcmwuOALIZuPdfofO5wvYlFcjw6DDXPnYta7auAWAkO8K/r/13WgdaC9yZtGczPCpygyOj3Pf0xF/m1jzXWYBuJGkOGh2e+Caud2tuPAmZIdi0dmIPgx63X7Xnfjlx7Jl7kvsZtjwxcez5X+eWzSVhoANGR8aPbVq7I7yaZsOjwxOCoo09G8lkM4nUIzsKL+7ynBjuzZ1xVQxG+iefoxubZ74XaRboz/SzdtvaCeNPtj9ZgG4kvcTwqMhVpks5/eCJ+x4ct8LToCVpSkrLYOGB48fq94XShPYgSlXmluPsLF2V/B49xeyA0yeOrXpzcvtILT5skh5Og/LaZOpVNeT2OdrZfq+fODZNykvL2at6r3FjK+atIF2S0H6KpWnY9/jxYxX1ub2rikFZFRz4xonjy0+Y+V6kWaAmXcOJS0+cML56weoCdCPpJYZHRa6kJPDmw5Zw7jF7U1oSqC4r5X+95RCW1SfzC6UkFZ2aRXDh9dC4Knd7wUp4x43J7ZdTOQ/O/n+5fXIA6pbCO2/KvVnWq7NgJZz6yVyYUpqGpj+DlZMEStOlqgHeflUu8AsBVr0Fjvur5MKqynp4x01QuyR3e9/j4M3/AhXJ7A3SUNnAladfyfK63J5KB9QfwL+f+u8sqFyQSD2qGuBProalR+Vu1++b29OpKqF6M62kFA47Fw6/IPd5eS286Z+gblmhO5MKIlWS4vxV53Pm8jMpCSXUpmv5zAmfoaHSP35LhRRiUuv9E9LU1BSbmz2Nd3f1DI7QPzxKAOoq01SkE75KkCQVm94WyA5DSTrxK1kB0N+WW3YUSnNX6krySlZ7gpGB3N5AMebenCd9JavMMAy05+qlK3MBT5JGR3P7c8XRXEg1A8FK20AbI9kR0iXp5IKjnfW1wuhQbkPpqkYoKbK/gQ52567SF0IuLC6WzcClV6lnuIeBzACBwLzyeZSVerEfKWkhhDUxxqbJ7vNqa3uI2oo0tRUJnU4uSXuCmoTONMqnWM6qmC3SlYkt45pUqgxq93rlx02X0tLkruaWx4wERjurXjiz9WZaRV3uQxIAtWW11JYltNxX0m4rsj/ZSJIkSZIkaToZHkmSJEmSJCkvwyNJkiRJkiTlZXgkSZIkSZKkvAyPJEmSJEmSlJfhkSRJkiRJkvIyPJIkSZIkSVJehkeSJEmSJEnKy/BIkiRJkiRJeRkeSZIkSZIkKS/DI0mSJEmSJOVleCRJkiRJkqS8DI8kSZqikdGRGS44CNnsjJXLZDNk48zVK3rZ0dzPcIbEGBnJzuwcnennxODoINkZfE4wOjKjz8Gil83CaKbQXUh5ZbIZRrOjhW6jaBTidUnJSRW6AUmSZruOwQ7ue/E+7nnhHk5cdiIn730yDRUNyRXs2QKb1sKjN8Neh8HhF0LdkuTKDffwbNez3PDEDSyrXcZ5B53HoqpFidXbI3S9AL/7L+jeBE1/Bg0roWZhYuVaB1r5wTM/4LG2xzjngHN4zYLXUF9Rn1i99sF2fv7Cz7nvxfs4dZ9TOX7p8cyvmJ9YvZb+FtZuW8tdz93FYQsP4037vynZOTrQCVsfgzX/DQtXwdEXQe1eydUrdtks9GyG330NerfA6z4IDftDeW2hO5MAGMwMsqVvC998/JukS9K8+9B3s7hqMenSdKFbm7PaBtq4Y8MdPNzyMG/Z/y0csegI6suTe11S8kKMsdA97JampqbY3Nxc6DYkSXuI3uFevtD8Bf5n/f9sH3vz/m/mk6/7JHXlddNfcGQQ7v8q3PXpHWNLj4ILvw11S6e/HvCrTb/ikrsu2X57cdVibjj7BhZWJhd2FLXuF+E/T8u9WX7JO2+Cg96YSLn2gXYuuesS1rWv2z72iWM/wfmrzidVMv1/J+we6uazv/ksP9rwo+1j5x90Ph875mNUl1VPe72+kT6ueeQa/vOR/9w+1rS4ic+f/PlkAqQY4bFb4eb37xhrWAF/9mOoMVR9VXq2wFdOgP623O0Q4M/uhH2OLWxf0pgNXRt4++1vJ5PNnRlXmarktrfdxtKaZF53i137YDuX/+xyHmx5cPvY5UdfznsOfQ9lpWUF7EyvJISwJsbYNNl9LluTJOll9Gf6ueWpW8aN3fHsHfRn+pMp2NcCv/ny+LEXH4Dh3kTKdQ51ctXDV40b29q/lac7n06k3h5hyyPjgyOAX/1b7g10AnpGesYFRwDXPHoNnUOdidQbyAzw4w0/Hjd2y/pb6Mv0JVKvZ7iH69ZdN26seWszg5mElgT2t8K9/zp+rP0Z6NqYTL09wfP37wiOIBfQ/eKfYaincD1JY7LZLNetu257cAS549wPn/lhAbua2/pH+scFRwBff+zrdA91F6gjTQfDI0mSXkFpKB13uySUEAgJFpzkr3K79DBdSighXTLxtPzJxjRFk/38SssgJPNrV8kkv84l/fMr2eV7KS1JZn4CEJl06ciuPUyfMPnPMMnvsdilJvn/mSpP7Dkh7ZYA5aXlE4Y9Q+bVC2Hi70jpkjRJ/uqk5HnEliTpZdSma3nfa943buzCgy+kOj39y3MAqNkLTvnb8WMrToV0VSLl6srruOyoy8a9EV8xbwXL65YnUm+P0LgKFh6043ZJKZzyicSWPNWU1XD8kuPHjV121GXML09mD6LqdDUXrLpg3Nj7V7+f2rJk9q+pr6jn4sMuHjd2xr5nTPpmb1pUL4TTP5VbWvWSJUdCrctXXrWlR0P9TseU0nTuOZHAMkdpd5WEEt5xyDuoSu14na0vr+eN+yez1HhPUJ2q5tR9Th039uGjPuyeR3Ocex5JkvQKOgc7ebrraX616Vcct+Q4Dpx/YKKbA9O7LbdEZt3tsOQI2Oe4RDfMHhgZYFv/Nu549g6W1S7j+KXHu9/RH6r7RVh/J3RtgsPOg+pGqEpuzrQPtPNAywOsa1vHmcvPZEnNEurKEtiTa0zHYAe/7/g992++n9cvez0r5q1IdIPu1v5WNvZu5O4X7ubwxsM5bOFhyW6YPdST+xk+eissXAn7vwFqGpOrtyfo3Qq/vzP372HnQs1iSFcWuisJgMxohtbBVn604UeUlZRxxvIzWFi5MMEzHItf+2A7D7c8zCOtj3D6vqezd83eyewVqWn1cnseGR5JkiRJkiTt4dwwW5IkSZIkSa+K4ZEkSZIkSZLyMjySJEmSJElSXoZHkiRJkiRJysvwSJIkSZIkSXkZHkmSJEmSJCkvwyNJkiRJkiTlZXgkSZIkSZKkvAyPJEmSJEmSlJfhkSRJkiRJkvIyPJIkSZIkSVJehkeSJEmSJEnKy/BIkiRJkiRJeaUK3YAk7REGOmC4DwhQVg2V9YXuSLtjNAP9rTAyAOlKqFoApelCdzWttvZuZig7QrokRVVJGfOqFha6pek10AUjfRBHIV0NVQ2F7mhOy4xm6BjqYDAzSGWqkvkV8yktKU2sXjZmaR9sZzAzSHlpOXXldZSXlidWT5IkjWd4JElJ62uF738U1t0OIcBrzoM3fQ6qi+zNebHKZmHLw/Dt86GvJRc6XHg9LGuC0uJ4Gd3Su5nL7/4Ij7c/TqokxcWHX8y5B7ydhTWLC93a9Ohrg59+Bh64FmKElWfB278M1Y2F7mxOymQzPNz6MJfdfRldQ10sqFjAladfySELDqEkJHNS+4auDVx818Vs6dtCTbqGfzrpnzhuyXGUpwyQJEmaCS5bk6SkPf3TXHAEuTeuj9wEL9xf2J40df0tcNN7csERQH873Pju3JlIRaB3oJOvPPxVHm9/HMgFA1c+eCVdmZ4CdzaNtjwCa7+Re/4BPHUnPHbbjtvaLR2DHXz0no/SNdQFQNtgG1f8/AraB9oTqdc+2M7f3vu3bOnbAkDvSC8f/8XH6RruSqSeJEmayPBIkpIUIzxzz8TxZ++d8Vb0Ko2OQNcL48f6WmB0uDD9TLPeTB+PtT42YXx9x1MF6CYhL/x64tiGXxbNz3CmDY8O0z44Pija1LuJTMwkUi8bszzR/sS4sYHMAAOZgUTqSZKkiQyPJClJIcChfzxx/OC3zHwvenVKy6Hx4PFj8/eDVEVB2plu88rqOH7JcePGAoFDFxxaoI4SsPLMiWOHnAMueXpVylPlLK1eOm7swPoDSZcksw9YuiTNMYuPGTc2r3weVemqROpJkqSJDI8kKWl7N8HrP5YLG9JVcMrfweLVhe5KU1XTCBd+G/Y6PHd70SHwzhuLZr+cyvJaLlr9Hs5afhYloYSGigY+d9LnqC2tLHRr06fhADjzs1BemwuMXvdBWHFKobuasxoqGvjyGV9mZf1KAA5pOIR/O/XfWFC5IJF688rn8Y+v/0eObDwSgH1r9+WqM65iftn8ROpJkqSJQpxj6/2bmppic3NzoduQpN0z3A9D3bnPK+blrtiluaWvJXfVtdJU0QRHO2vr28bw2LKjhnQ95eVFdlbHyCAMduY+L6+DsiL7/gqgbaCN0ThKKqRoqEz+6nWdg50MZ4cpDaU0VDQQQki8piRJe5IQwpoYY9Nk9xXHZWIkabYrq/LN6lxXhIHRzhZULyp0C8lKV0B6r0J3UVSSOtMon/qK+hmtJ0mSdnDZmiRJkiRJkvIyPJIkSZIkSVJehkeSJEmSJEnKy/BIkiRJkiRJeRkeSZIkSZIkKS/DI0mSJEmSJOVleCRJkiRJkqS8DI8kSZIkSZKUl+GRJEmSJEmS8jI8kiRJkiRJUl6GR5IkSZIkScrL8EiSJEmSJEl5GR5JkuambBZGBgrdRbJGBiE7OnP1MkOQzcxcvSKXyWYYHh0udBuSJBVENmYZzAwWug1Nk1ShG5Akabf1boOHboCNv4XVfwIr3gBVCwrd1fTpb4Pnf5P7HpccCUe/G2oWJ1dvoBO2PQ6/vRrql8PrLobaJRBCcjWLWIyRbf3buG7ddbzY9yLvPPidrJy/krqyukK3JknSjGgdaOX2p2/n4ZaHefP+b+a1e72W+RXzC92W/gAhxljoHnZLU1NTbG5uLnQbkqRC6WuFG94JL9y/Y+zkj8NJfw3pisL1NV0yw3D/V+Ann9oxttdhcNGtUN2YTM0nfwTXX7Djds1iuPheqE0wsCpiLf0tnPe982gbbNs+9uXTv8xJe59UwK4kSZoZ7YPtXPrTS3m09dHtY5ceeSnvX/1+ylPlBexMrySEsCbG2DTZfS5bkyTNLcN944MjgN98BQa7CtPPdBvogF9/afzYlkdgsDuZev3t8MsvjB/r3Qrb1iVTbw+wvmP9uOAI4GuPfI2uoSKZo5IkvYy+kb5xwRHANx//Jj3DPQXqSNPB8EiSNLeESV660hVQLCusApCqnDhektBK81AC6UnqTTamKalITTwDrjxVTslkc1eSpCJTGkonjFWkiuh3tT2Uv8VIkuaWshp4zbnjx07/e6gskj2PqhbCGX8/fuygP4LymmTqVdbD6Z8aH04tXg0NK5KptwdYXrecA+sP3H47FVJcftTl1JbVFrArSZJmRlWqijOXnzlu7PKjLmd+uXsezWXueSRJmnv6WnNLuTathYPOgnn75EKQYjHYBd0vwpN35PY7WnpkcvsdAYz0Q89WWPd9qN8blp8INYuSq7cHaBtoo3lrM5t7N3P68tNZWLmQysnOKJMkqQi1D7bzRNsTPN7+OCcvO5m9avbywhFzwMvteWR4JEmSJEmStIdzw2xJkiRJkiS9KoZHkiRJkiRJysvwSJIkSZIkSXkZHkmSJEmSJCkvwyNJkiRJkiTlZXgkSZIkSZKkvAyPJEmSJEmSlJfhkSRJkiRJkvIyPJIkSZIkSVJehkeSJEmSJEnKy/BIkiRJkiRJeRkeSZIkSZIkKa/EwqMQwj4hhLtDCOtCCI+FEC6f5DGnhBC6QggPjn18Kql+JEmSJEmStPtSCX7tDHBFjHFtCKEWWBNC+EmM8fFdHndvjPHsBPuQtJtGs6O0D7YzkBmgIlXBvLJ5lKfKC93W9OprgeE+KElDeS1U1BW6I+2OkQEY6Mz9W1YN1QuhpDS5eqMj0N+WmzNl1VDZAKmyxMrFGGkbaKM/009FqoLasloqU5WJ1ZN21/BwH53D3QxmBqhMVTK/fD6pdEWh29Ju6BzqZGBkAIDKVCX1FfUF7kiSNJslFh7FGDcDm8c+7wkhrAOWAbuGR5JmmfUd67n4rotpH2ynKlXFv7zhXzh2ybGUlxZJgNSzFa6/AF58AEIJHHcpnPQxqGoodGeaiuEBeOoncOvFMNIPtXvBRd+FRQcnUy87Ci8+CN8+DwY6oGIeXPht2Od1UJpOpORz3c/xgZ98gC19WygvLefTx3+a0/c9nap0VSL1pN2RGRnkwZaHuPznV9A70su88nl8+dT/4DULD6ekNMm/S2q6tA+089nffJa7nr8LgFP2PoXPnPAZGip9HZQkTW5G9jwKIewHHAXcP8ndx4cQHgoh3BFCWD0T/UjKr22gjY//4uO0D7YD0J/p529+8Td0DXUVuLNpkhmCX1+ZC44AYhZ+/UXo2ljYvjR1Q51wywdywRFAzxa49S+hrzWZen2t8D/vzQVHAINdudv9bYmU6xzs5NP3fZotfVsAGBod4lP3fYrekd5E6km7q2Oogyvu/f+2z8muoS7++t6/pX2gpcCdaaqatzZvD44A7tl4D7968VcF7EiSNNslHh6FEGqA7wAfiTF273L3WmB5jPEI4IsnwGVzAAAWqklEQVTAbXm+xl+GEJpDCM0tLf5iIiVpNI6yoXvDuLHekV6GMkOFaWi6DffDxt9OHN/62Mz3oldnuA8yg+PHtjySO0MoCdkR6N40fqyvFUaHEyk3kh3hyY4nx41lshm6h3d9CZUKYzg7TOdQ57ixzX2bycSEnoOadmu2rpkw9rstvytAJ5KkuSLR8CiEkCYXHF0XY7xl1/tjjN0xxt6xz38IpEMICyd53NUxxqYYY1NjY2OSLUt7vLKSMo5oPGLc2KKqRcWz30p5HRw8yTZr+xw7873o1SmrnbjEcMUpkNS+XKXlsHiXE2MbVkAqmf1dKlOVHL/k+HFj1elq5pXNS6SetLvKS8rYu3bvcWOr5q+iLLhkba44Y/kZE8beuN8bC9CJJGmuSPJqawG4BlgXY/xCnsfsNfY4QgjHjvWTzDoASVNSX1HPP5/8zxy96GgADpp/EFedcRXzK+YXuLNpUloKR1wIx7wPSsuguhH+9Jrcv5obqhbARbfBwoNyt/c/Gc75ElQmtNlrTSNccB0sOyZ3e8kR8M6bEpszNWU1fOJ1n+D1S19PILC8bjlXn3k19eVuZqvZYUHVYr5y6hc5pOEQAA5feDj/7w3/SkPNXgXuTFN1YP2BfOToj1CdrqYqVcWlR17K6oXuHiFJyi/EGJP5wiG8HrgXeATIjg3/HbAvQIzxqyGEDwEfJHdltgHgYzHG+17u6zY1NcXm5uZEepa0Q+dgJyPZEUpDaXFuoDncB0O9EIDKBeAmr3NPbwvE0dyZQVUzEG72teWWsJWkcld3S1j3UDdDo0OUhBIaKhoY+1uLNGt09G4hQyQVSphfvbjQ7Wg3DWWG6BnpgQh15XWUlSZ3BUlJ0twQQlgTY2ya9L6kwqOkGB5JkiRJkiRNr5cLj2bkamuSJEmSJEmamwyPJEmSJEmSlJfhkSRJkiRJkvIyPJIkSZIkSVJehkeSJEmSJEnKy/BIkiRJkiRJeRkeSZIkSZIkKS/DI0mSJEmSJOVleCRJkiRJkqS8DI8kSZIkSZKUl+GRJEmSJEmS8jI8kiRJkiRJUl6GR5ImFyMM98HoaKE7kSY3OgL9HYXuQpIkSSp6qUI3IGkW6muFJ34AT3wflp8AR74LahYVuitph+4Xofm/YctDsOpsOOgsqN2r0F1JkiRJRcnwSNJ4w31wz+fgd1/L3V5/Jzz1UzjvG1C9oLC9SZALjm58F2xam7v9+x/D8R+GU/4/KK8tbG+SJElSEXLZmqTxhnpg7bXjxzbcCyN9helH2tXIwI7g6CVr/gsGuwvTjyRJklTkDI8kTZSuHH87lEAoLUwv0q5KJjlptqwaiDPeiiRJkrQnMDySNF5lA5z2qfFjTX8O5TWF6UfaVaoCDjt//Nhp/xuqGgvTjyRJklTk3PNI0nipMjjsXFh+PDxzDyxrgoUroWJeoTuTcmoXw5n/AEe9C158AFaeATWLIV1e6M4kSZKkomR4JGmiyvrcx+LVhe5EmlzdktzHilMK3YkkSZJU9Fy2JkmSJEmSpLwMjyRJkiRJkpSX4ZEkSZIkSZLyMjySJEmSJElSXoZHkiRJkiRJysvwSJIkSZIkSXkZHkmSJEmSJCkvwyNJkiRJkiTlZXgkSZIkSZKkvAyPJEmSJEmSlJfhkSRJkiRJkvIyPJIkSZIkSVJehkeSJEmSJEnKK1XoBlScOvqH6R8aJRKpKkvRUF1W6JY0m8UIvdtguA/SFVBeB+U1he5Ks9lwPwx2wUg/lFVDVSOUlha6K2nPMTIIg50w3AtlNVDZAClf6yVJKlaGR5p2bb1D/O13HuEn67YCcMIBC/jiO45iQU15gTvTrNWxAb5xNnRthJIUnPlZOOpdUDGv0J1pNhruhyd/CN/9K8gMQfVCeM93YfFrCt2ZtGcYHYHn74Mb350L/cvr4F3/A3u/FkoMcSVJKkYuW9O0+92G9u3BEcB9T7dx5+NbX+a/0B5toBN+cEUuOALIZuDOv8udVSJNZrBrR3AE0NcKt16S+1dS8vrb4OY/ywVHAEPduds+ByVJKlqGR5p2a5/rnDD2uw3tZLOxAN1o1ssMwrbHx4+9tIxNmsxI/47g6CVbH4PsaGH6kfY0mSEY6Bg/1r0pF/5LkqSiZHikaffG1+w1YeycI5ZSUhIK0I1mvfI6OPCs8WPpSpi3rDD9aPYrq84tVdvZAadDyqWx0oxIV0LDivFjS470OShJUhEzPNK0O6Cxms+ccyj1VWnqKlJ8/I2rOGKf+kK3pdmqrApO+ySs/pPcfkcLVsJF34WKhkJ3ptmqqjG3x9Feh+X2V1l5JpzzH1DpcUaaEdWN8K6bYe8mCCWw/ES44JsTQ11JklQ0QoxzaylRU1NTbG5uLnQbegXDmSyd/cMQoL6yjLKUOaVewWA3jAxACFCzqNDdaC7oa80tVUuVGxxJhfDSc7A0DVUG/pIkzXUhhDUxxqbJ7vNqa0pEWaqERXUVhW5Dc0lFXe5DmirPcpAKy+egJEl7DE8HkSRJkiRJUl6GR5IkSZIkScrL8EiSJEmSJEl5GR5JkiRJkiQpL8MjSZIkSZIk5WV4JEmSJEmSpLwMjyRJkiRJkpSX4ZEkSZIkSZLyMjySJEmSJElSXoZHkiRJkiRJysvwSJIkSZIkSXkZHkmSJEmSJCkvwyNJkrRHGBzqoX+oq9BtJCczAoPdEGOhO5EkSUUmVegGJEmSkjQ01Mumvhf56iNXMzQ6wl+sfi8r6vanunJ+oVubPj2b4ddfhq2PwmHnw0FnQdWCQnclSZKKhOGRJEkqam1DHZz3g3cwnB0G4O4X7ubGN3+bQ4olPOrdBt94K7Suz91++mdw6ifhxI9AqqywvUmSpKLgsjVJklTU7nz2ju3BEUAk8q0nrmMkM1jArqbRYOeO4Oglv/tPGOgoTD+SJKnoGB5JkqSiNq983oSx+rI6SkJpAbpJQGn5xLHyOghh5nuRJElFyfBIkiQVtdfv8waWVi/dfruurI53H3oRpaXpAnY1jcprYfWf7LgdArzxc1DdWLieJElSUQlxjl2Ro6mpKTY3Nxe6DUmSNIe09m3lwa1rGMwMcuzS41lQsZDSVJGERwB9rbmlay3rYP83QM1iKK8pdFeSJGkOCSGsiTE2TXafG2ZLkqSit7B6MWeseHOh20hO9cLcx/LjC92JJEkqQi5bkyRJkiRJUl6GR5IkSZIkScrL8EiSJEmSJEl5GR5JkiRJkiQpL8MjSZIkSZIk5WV4JEmSJEmSpLwMjyRJkiRJkpSX4ZEkSZIkSZLyMjySJEmSJElSXoZHkiRJkiRJysvwSJIkSZIkSXkZHkmSJEmSJCkvwyNJkiRJkiTlZXgkSZIkSZKkvAyPJEmSJEmSlJfhkSRJkiRJkvIyPJIkSZIkSVJehkeSJEmSJEnKy/BIkiRJkiRJeRkeSZIkSZIkKS/DI0mSJEmSJOVleCRJkiRJkqS8DI8kSZIkSZKUl+GRJEmSJEmS8jI8kiRJkiRJUl6GR5IkSZIkScrL8EiSJEmSJEl5GR5JkiRJkiQpL8MjSZIkSZIk5WV4JEmSJEmSpLwMjyRJkiRJkpSX4ZEkSZIkSZLyMjySJEmSJElSXomFRyGEfUIId4cQ1oUQHgshXD7JY0II4T9CCE+FEB4OIRydVD+SZrkYYaATRgYL3YkkSZIkaSepBL92Brgixrg2hFALrAkh/CTG+PhOj/kj4MCxj9cBXxn7V9KepL8dnvwRPHQdLDgITr4C5u1d6K4kSZIkSSR45lGMcXOMce3Y5z3AOmDZLg97G3BtzPkNUB9CWJJUT5JmodEReOBb8N0PwoZfwpr/gmvOgt6the5MkiRJksQM7XkUQtgPOAq4f5e7lgEv7HR7IxMDJknFrL8dmq8ZP9a9CXq2FKYfSZIkSdI4iYdHIYQa4DvAR2KM3bvePcl/Eif5Gn8ZQmgOITS3tLQk0aakQikphYr6iePpqpnvRZIkSZI0QaLhUQghTS44ui7GeMskD9kI7LPT7b2BF3d9UIzx6hhjU4yxqbGxMZlmJRVG9UJ40+egZKct2Fa9BaoaCteTJEmSJGm7xDbMDiEE4BpgXYzxC3kedjvwoRDCDeQ2yu6KMW5OqidJs9TSI+GyB+C5+6BhRe6jakGhu5IkSZIkkezV1k4ELgIeCSE8ODb2d8C+ADHGrwI/BN4MPAX0A+9PsB9Js1W6Cur3zX1IkiRJkmaVxMKjGOMvmXxPo50fE4FLk+pBkiRJkiRJf5gZudqaJEmSJEmS5ibDI0mSJEmSJOVleCRJkiRJkqS8DI8kSZIkSZKUl+GRJEmSJEmS8jI8kiRJkiRJUl6GR5IkSZIkScrL8EiSJEmSJEl5GR5JkiRJkiQpL8MjSZIkSZIk5WV4JEmSJEmSpLwMjyRJkiRJkpSX4ZEkSZIkSZLyMjySJEmSJElSXoZHkiRJkiRJysvwSJIkSZIkSXkZHkmSJEmSJCkvwyNJkiRJkiTlZXgkSZIkSZKkvAyPJEmSJEmSlJfhkSRJkiRJkvIKMcZC97BbQggtwHOF7kNTthBoLXQTmlOcM9odzhftLueMdpdzRrvD+aLd5ZzR7kpyziyPMTZOdsecC480t4QQmmOMTYXuQ3OHc0a7w/mi3eWc0e5yzmh3OF+0u5wz2l2FmjMuW5MkSZIkSVJehkeSJEmSJEnKy/BISbu60A1oznHOaHc4X7S7nDPaXc4Z7Q7ni3aXc0a7qyBzxj2PJEmSJEmSlJdnHkmSJEmSJCkvwyNNmxBCaQjhgRDC9ye5730hhJYQwoNjH39RiB41e4QQNoQQHhmbD82T3B9CCP8RQngqhPBwCOHoQvSp2WEK8+WUEELXTseYTxWiT80eIYT6EMLNIYQnQgjrQgjH73K/xxhtN4X54jFG24UQVu00Fx4MIXSHED6yy2M8xmi7Kc4ZjzMaJ4Tw0RDCYyGER0MI14cQKna5vzyEcOPYceb+EMJ+SfaTSvKLa49zObAOqMtz/40xxg/NYD+a/U6NMbbmue+PgAPHPl4HfGXsX+25Xm6+ANwbYzx7xrrRbPfvwI9ijOeGEMqAql3u9xijnb3SfAGPMRoTY3wSOBJyfzwFNgG37vIwjzHabopzBjzOaEwIYRlwGXBojHEghHATcCHw9Z0e9udAR4xxZQjhQuDzwAVJ9eSZR5oWIYS9gbcAXyt0LyoabwOujTm/AepDCEsK3ZSk2S+EUAecDFwDEGMcjjF27vIwjzECpjxfpHxOB56OMT63y7jHGOWTb85Iu0oBlSGEFLk/ary4y/1vA74x9vnNwOkhhJBUM4ZHmi7/BvwNkH2Zx/zp2Gm7N4cQ9pmhvjR7ReDOEMKaEMJfTnL/MuCFnW5vHBvTnumV5gvA8SGEh0IId4QQVs9kc5p1VgAtwH+PLaf+WgihepfHeIzRS6YyX8BjjCZ3IXD9JOMeY5RPvjkDHmc0Jsa4CfgX4HlgM9AVY7xzl4dtP87EGDNAF7AgqZ4Mj/QHCyGcDWyLMa55mYd9D9gvxng4cBc7ElLtuU6MMR5N7rTuS0MIJ+9y/2SpuZeH3HO90nxZCyyPMR4BfBG4baYb1KySAo4GvhJjPAroA/52l8d4jNFLpjJfPMZogrEljucA/zPZ3ZOMeYzZw73CnPE4o+1CCPPJnVm0P7AUqA4hvHvXh03ynyZ2nDE80nQ4ETgnhLABuAE4LYTwrZ0fEGNsizEOjd38T+CYmW1Rs02M8cWxf7eRW/N97C4P2QjsfIba3kw8VVN7iFeaLzHG7hhj79jnPwTSIYSFM96oZouNwMYY4/1jt28mFw7s+hiPMYIpzBePMcrjj4C1Mcatk9znMUaTyTtnPM5oF2cAz8YYW2KMI8AtwAm7PGb7cWZsads8oD2phgyP9AeLMX4ixrh3jHE/cqdh/izGOC4V3WWN9znkNtbWHiqEUB1CqH3pc+As4NFdHnY78J6xq5UcR+5Uzc0z3KpmganMlxDCXi+t8Q4hHEvu9a1tpnvV7BBj3AK8EEJYNTZ0OvD4Lg/zGCNgavPFY4zyeAf5lx95jNFk8s4ZjzPaxfPAcSGEqrF5cToT30PfDrx37PNzyb0PT+zMI6+2psSEEP4BaI4x3g5cFkI4B8iQS0PfV8jeVHCLgVvHXh9TwLdjjD8KIVwCEGP8KvBD4M3AU0A/8P4C9arCm8p8ORf4YAghAwwAFyb54qk54cPAdWNLBJ4B3u8xRi/jleaLxxiNE0KoAs4ELt5pzGOM8prCnPE4o+1ijPeHEG4mt5wxAzwAXL3Le+xrgG+GEJ4i9x77wiR7Cs5HSZIkSZIk5eOyNUmSJEmSJOVleCT9/+3dX8iecxzH8fcHm2JjivQcWPJvCwez1Zj/ipWSmhYpBys5ISVRimjmvxOh4YByIBnhwMGYeMg2aZvZZuRfaEgmzSP1YPs6uH9P7oPn2u4xnh57v+rpuu7vdf2+1/f3HN19+/2uW5IkSZIkdbJ5JEmSJEmSpE42jyRJkiRJktTJ5pEkSZIkSZI62TySJEmTXpJbk3yYZFOSjUlO34e5z0/ySjtfkuTRfZV7nGfNSHLteM8e594pSe5L8mmSLUneS3Lxv1WbJEnafx000QVIkiT9E0kWAJcAc6tqNMmRwNQJLuvvmgFcCywf4N5lwBBwapv30cB5/2ZxkiRp/+TKI0mSNNkNAdurahSgqrZX1bdJ5iV5K8n6JK8mGQJIMpzkoSRr2oqd+S0+v8Xeb8dZgxaQZGGStUk2JHk+ybQW/zLJ0hbfnGR2ix+VZFWLP5Hkq9b0ug84vq2eerCln5bkhSQfJ3kmPYcA1wDX9837+6pa0fL/kuT+NvfX29yGk3yR5NJ98U+XJEn7D5tHkiRpsnsNOCbJJ0mWJzkvyRTgEWBxVc0DngLu7htzaFWdSW+Vz1Mt9jFwblWdBtwO3DPIw1vT5zbgwqqaC6wDbuy7ZXuLPwbc1GJ3AG+0+EvAzBa/Bfi8quZU1c0tdhpwA3AycBxwFnAC8HVV/dxR1qHAcJv7CHAXcBGwCLhzkHlJkiSNcduaJEma1KrqlyTzgHOAC4Dn6DVLTgVWJQE4EPiub9izbezbSQ5LMgOYDjyd5ESggCkDlnAGvcbO6vasqcDavusvtuN64LJ2fja9Rg5VtTLJT7vJ/15VbQNIshE4Fti0h5p+A1a2883AaFX9nmRzGy9JkjQwm0eSJGnSq6qdwDAw3Bok1wEfVtWCriHjfF4GvFlVi5Ic2/INIsCqqrqy4/poO+7kr+9eGTB3//j+HJ8BM5NMr6qRccb8XlVjc9w1lqOqdiXx+58kSdorbluTJEmTWpJZbbXQmDnAR8BR7WXaY79MdkrfPVe0+NnAjqraARwOfNOuL9mLEt4FzkpyQst5SJKT9jDmHeDydv9C4IgWH6G3Amq3qupX4Eng4SRTW56hJFftRd2SJEkDsXkkSZImu2n0tpttTbKJ3hay24HFwP1JPgA2Amf2jfkpyRrgceDqFnsAuDfJanrb3LosSbJt7A84mF6z6dn2/HeB2XuoeSmwMMkG4GJ6W+pGqupHetvftvS9MLvLbcAPwNYkW4CX22dJkqR9Kn+taJYkSfr/SzIM3FRV6yawhoOBnVX1R1sd9VhVzZmoeiRJknbHPe+SJEn/vZnAiiQH0Hu59TUTXI8kSVInVx5JkiRJkiSpk+88kiRJkiRJUiebR5IkSZIkSepk80iSJEmSJEmdbB5JkiRJkiSpk80jSZIkSZIkdbJ5JEmSJEmSpE5/AjNkuLeGrnjhAAAAAElFTkSuQmCC\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "sns.scatterplot(x=\"SepalLengthCm\", y=\"SepalWidthCm\", hue=\"Species\", data=data)" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 10, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "sns.distplot(data[data.Species == \"Iris-setosa\"].PetalLengthCm)\n", + "sns.distplot(data[data.Species == \"Iris-versicolor\"].PetalLengthCm,color=\"r\")\n", + "sns.distplot(data[data.Species == \"Iris-virginica\"].PetalLengthCm,color=\"g\")" + ] + }, + { + "cell_type": "code", + "execution_count": 46, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 46, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "sns.pairplot(data, hue=\"Species\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Data Preprocessing" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [], + "source": [ + "from sklearn.preprocessing import LabelEncoder\n", + "from sklearn.model_selection import train_test_split\n", + "from sklearn.metrics import accuracy_score" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
IdSepalLengthCmSepalWidthCmPetalLengthCmPetalWidthCmSpeciesLabel
015.13.51.40.2Iris-setosa0
124.93.01.40.2Iris-setosa0
234.73.21.30.2Iris-setosa0
344.63.11.50.2Iris-setosa0
455.03.61.40.2Iris-setosa0
\n", + "
" + ], + "text/plain": [ + " Id SepalLengthCm SepalWidthCm PetalLengthCm PetalWidthCm Species \\\n", + "0 1 5.1 3.5 1.4 0.2 Iris-setosa \n", + "1 2 4.9 3.0 1.4 0.2 Iris-setosa \n", + "2 3 4.7 3.2 1.3 0.2 Iris-setosa \n", + "3 4 4.6 3.1 1.5 0.2 Iris-setosa \n", + "4 5 5.0 3.6 1.4 0.2 Iris-setosa \n", + "\n", + " Label \n", + "0 0 \n", + "1 0 \n", + "2 0 \n", + "3 0 \n", + "4 0 " + ] + }, + "execution_count": 13, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "label_encoder = LabelEncoder()\n", + "data[\"Label\"] = label_encoder.fit_transform(data[\"Species\"]) \n", + "data.head()" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "2 50\n", + "1 50\n", + "0 50\n", + "Name: Label, dtype: int64" + ] + }, + "execution_count": 14, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "data[\"Label\"].value_counts()" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "['Iris-setosa', 'Iris-versicolor', 'Iris-virginica']" + ] + }, + "execution_count": 15, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "categories = list(label_encoder.inverse_transform([0, 1, 2]))\n", + "categories" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [ + { + "ename": "AttributeError", + "evalue": "'DataFrame' object has no attribute 'Species'", + "output_type": "error", + "traceback": [ + "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[1;31mAttributeError\u001b[0m Traceback (most recent call last)", + "\u001b[1;32m\u001b[0m in \u001b[0;36m\u001b[1;34m\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m \u001b[0mclases\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mlist\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mset\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mdata\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mSpecies\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m 2\u001b[0m \u001b[0mdata\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mdrop\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;34m\"Id\"\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;34m\"Species\"\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0maxis\u001b[0m\u001b[1;33m=\u001b[0m\u001b[1;36m1\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0minplace\u001b[0m\u001b[1;33m=\u001b[0m\u001b[1;32mTrue\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", + "\u001b[1;32m~\\Anaconda3\\lib\\site-packages\\pandas\\core\\generic.py\u001b[0m in \u001b[0;36m__getattr__\u001b[1;34m(self, name)\u001b[0m\n\u001b[0;32m 5271\u001b[0m \u001b[1;32mif\u001b[0m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0m_info_axis\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0m_can_hold_identifiers_and_holds_name\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mname\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 5272\u001b[0m \u001b[1;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[1;33m[\u001b[0m\u001b[0mname\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m-> 5273\u001b[1;33m \u001b[1;32mreturn\u001b[0m \u001b[0mobject\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0m__getattribute__\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mself\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mname\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m 5274\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 5275\u001b[0m \u001b[1;32mdef\u001b[0m \u001b[0m__setattr__\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mself\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mname\u001b[0m\u001b[1;33m:\u001b[0m \u001b[0mstr\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mvalue\u001b[0m\u001b[1;33m)\u001b[0m \u001b[1;33m->\u001b[0m \u001b[1;32mNone\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", + "\u001b[1;31mAttributeError\u001b[0m: 'DataFrame' object has no attribute 'Species'" + ] + } + ], + "source": [ + "clases = list(set(data.Species))\n", + "data.drop([\"Id\",\"Species\"], axis=1, inplace=True)" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
SepalLengthCmSepalWidthCmPetalLengthCmPetalWidthCmLabel
05.13.51.40.20
14.93.01.40.20
24.73.21.30.20
34.63.11.50.20
45.03.61.40.20
\n", + "
" + ], + "text/plain": [ + " SepalLengthCm SepalWidthCm PetalLengthCm PetalWidthCm Label\n", + "0 5.1 3.5 1.4 0.2 0\n", + "1 4.9 3.0 1.4 0.2 0\n", + "2 4.7 3.2 1.3 0.2 0\n", + "3 4.6 3.1 1.5 0.2 0\n", + "4 5.0 3.6 1.4 0.2 0" + ] + }, + "execution_count": 18, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "data.head()" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": {}, + "outputs": [], + "source": [ + "X, y = data.iloc[: , :-1], data.iloc[: , -1]" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": {}, + "outputs": [], + "source": [ + "X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.33, random_state=123)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Model" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Accuracy of train: 0.99\n", + "Accuracy of test: 0.96\n" + ] + } + ], + "source": [ + "from sklearn.tree import DecisionTreeClassifier\n", + "\n", + "clf = DecisionTreeClassifier(max_depth=4 , random_state=42)\n", + "clf.fit(X_train,y_train)\n", + "print(\"Accuracy of train:\",clf.score(X_train,y_train))\n", + "print(\"Accuracy of test:\",clf.score(X_test,y_test))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Bias for training = 1-0.99 = 0.01 \n", + "Bias for test = 1-0.96 = 0.04 \n", + "\n", + "Variance = test bias - training bias = 0.03 " + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": {}, + "outputs": [ + { + "data": { + "image/svg+xml": [ + "\r\n", + "\r\n", + "\r\n", + "\r\n", + "\r\n", + "\r\n", + "Tree\r\n", + "\r\n", + "\r\n", + "0\r\n", + "\r\n", + "PetalLengthCm <= 2.45\r\n", + "gini = 0.662\r\n", + "samples = 100\r\n", + "value = [30, 39, 31]\r\n", + "class = Iris-versicolor\r\n", + "\r\n", + "\r\n", + "1\r\n", + "\r\n", + "gini = 0.0\r\n", + "samples = 30\r\n", + "value = [30, 0, 0]\r\n", + "class = Iris-setosa\r\n", + "\r\n", + "\r\n", + "0->1\r\n", + "\r\n", + "\r\n", + "True\r\n", + "\r\n", + "\r\n", + "2\r\n", + "\r\n", + "PetalWidthCm <= 1.75\r\n", + "gini = 0.493\r\n", + "samples = 70\r\n", + "value = [0, 39, 31]\r\n", + "class = Iris-versicolor\r\n", + "\r\n", + "\r\n", + "0->2\r\n", + "\r\n", + "\r\n", + "False\r\n", + "\r\n", + "\r\n", + "3\r\n", + "\r\n", + "PetalLengthCm <= 5.35\r\n", + "gini = 0.136\r\n", + "samples = 41\r\n", + "value = [0, 38, 3]\r\n", + "class = Iris-versicolor\r\n", + "\r\n", + "\r\n", + "2->3\r\n", + "\r\n", + "\r\n", + "\r\n", + "\r\n", + "8\r\n", + "\r\n", + "PetalLengthCm <= 4.85\r\n", + "gini = 0.067\r\n", + "samples = 29\r\n", + "value = [0, 1, 28]\r\n", + "class = Iris-virginica\r\n", + "\r\n", + "\r\n", + "2->8\r\n", + "\r\n", + "\r\n", + "\r\n", + "\r\n", + "4\r\n", + "\r\n", + "SepalLengthCm <= 5.0\r\n", + "gini = 0.05\r\n", + "samples = 39\r\n", + "value = [0, 38, 1]\r\n", + "class = Iris-versicolor\r\n", + "\r\n", + "\r\n", + "3->4\r\n", + "\r\n", + "\r\n", + "\r\n", + "\r\n", + "7\r\n", + "\r\n", + "gini = 0.0\r\n", + "samples = 2\r\n", + "value = [0, 0, 2]\r\n", + "class = Iris-virginica\r\n", + "\r\n", + "\r\n", + "3->7\r\n", + "\r\n", + "\r\n", + "\r\n", + "\r\n", + "5\r\n", + "\r\n", + "gini = 0.5\r\n", + "samples = 2\r\n", + "value = [0, 1, 1]\r\n", + "class = Iris-versicolor\r\n", + "\r\n", + "\r\n", + "4->5\r\n", + "\r\n", + "\r\n", + "\r\n", + "\r\n", + "6\r\n", + "\r\n", + "gini = 0.0\r\n", + "samples = 37\r\n", + "value = [0, 37, 0]\r\n", + "class = Iris-versicolor\r\n", + "\r\n", + "\r\n", + "4->6\r\n", + "\r\n", + "\r\n", + "\r\n", + "\r\n", + "9\r\n", + "\r\n", + "SepalWidthCm <= 3.0\r\n", + "gini = 0.5\r\n", + "samples = 2\r\n", + "value = [0, 1, 1]\r\n", + "class = Iris-versicolor\r\n", + "\r\n", + "\r\n", + "8->9\r\n", + "\r\n", + "\r\n", + "\r\n", + "\r\n", + "12\r\n", + "\r\n", + "gini = 0.0\r\n", + "samples = 27\r\n", + "value = [0, 0, 27]\r\n", + "class = Iris-virginica\r\n", + "\r\n", + "\r\n", + "8->12\r\n", + "\r\n", + "\r\n", + "\r\n", + "\r\n", + "10\r\n", + "\r\n", + "gini = 0.0\r\n", + "samples = 1\r\n", + "value = [0, 0, 1]\r\n", + "class = Iris-virginica\r\n", + "\r\n", + "\r\n", + "9->10\r\n", + "\r\n", + "\r\n", + "\r\n", + "\r\n", + "11\r\n", + "\r\n", + "gini = 0.0\r\n", + "samples = 1\r\n", + "value = [0, 1, 0]\r\n", + "class = Iris-versicolor\r\n", + "\r\n", + "\r\n", + "9->11\r\n", + "\r\n", + "\r\n", + "\r\n", + "\r\n", + "\r\n" + ], + "text/plain": [ + "" + ] + }, + "execution_count": 24, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "#Visualization\n", + "\n", + "import os\n", + "from sklearn.tree import export_graphviz\n", + "# We need to locate graphiz directory for visualization (after conda)\n", + "os.environ[\"PATH\"] += ';' + r'C:\\Users\\Dell\\Anaconda3\\Library\\bin\\graphviz'\n", + "\n", + "import graphviz\n", + "\n", + "dot_data = export_graphviz(clf, out_file=None,\n", + " feature_names=X.columns,\n", + " class_names=categories,\n", + " filled=True, rounded=True)\n", + "graph = graphviz.Source(dot_data)\n", + "graph" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "#Feature Importance\n", + "plt.figure(figsize=(12, 8))\n", + "importance = clf.feature_importances_\n", + "sns.barplot(x=importance, y=X.columns)\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([0.01455535, 0.01534213, 0.55508492, 0.4150176 ])" + ] + }, + "execution_count": 26, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "importance" + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " precision recall f1-score support\n", + "\n", + " 0 1.00 1.00 1.00 20\n", + " 1 0.85 1.00 0.92 11\n", + " 2 1.00 0.89 0.94 19\n", + "\n", + " accuracy 0.96 50\n", + " macro avg 0.95 0.96 0.95 50\n", + "weighted avg 0.97 0.96 0.96 50\n", + "\n" + ] + } + ], + "source": [ + "from sklearn.metrics import precision_score, recall_score, accuracy_score, classification_report, f1_score\n", + "pred = clf.predict(X_test)\n", + "print(classification_report(y_test,pred))" + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Precision = 0.9487179487179488\n", + "Recall = 0.9649122807017544\n", + "Accuracy = 0.96\n", + "F1 Score = 0.9537037037037036\n" + ] + } + ], + "source": [ + "print(\"Precision = {}\".format(precision_score(y_test, pred, average='macro')))\n", + "print(\"Recall = {}\".format(recall_score(y_test, pred, average='macro')))\n", + "print(\"Accuracy = {}\".format(accuracy_score(y_test, pred)))\n", + "print(\"F1 Score = {}\".format(f1_score(y_test, pred,average='macro')))" + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "from sklearn.metrics import confusion_matrix\n", + "\n", + "cm = confusion_matrix(y_test, pred)\n", + "plt.figure(figsize=(12, 8))\n", + "ax =sns.heatmap(cm, square=True, annot=True, cbar=False)\n", + "ax.xaxis.set_ticklabels(categories, fontsize = 12)\n", + "ax.yaxis.set_ticklabels(categories, fontsize = 12, rotation=0)\n", + "ax.set_xlabel('Predicted Labels',fontsize = 15)\n", + "ax.set_ylabel('True Labels',fontsize = 15)\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Enseble Learning\n", + "\n", + "In ensemble learning theory, we call weak learners (or base models) models that can be used as building blocks for designing more complex models by combining several of them. Most of the time, these basics models perform not so well by themselves either because they have a high bias or high variance. The idea of ensemble methods is to try reducing bias and/or variance of such weak learners by combining several of them together in order to create a strong learner (or ensemble model) that achieves better performances. \n", + " \n", + "Combining weak learners:\n", + "\n", + "**Bagging**: that often considers homogeneous weak learners, learns them independently from each other in parallel and combines them following some kind of deterministic averaging process \n", + "
\n", + "**Boosting**, that often considers homogeneous weak learners, learns them sequentially in a very adaptative way (a base model depends on the previous ones) and combines them following a deterministic strategy \n", + "
\n", + "**Stacking**, that often considers heterogeneous weak learners, learns them in parallel and combines them by training a meta-model to output a prediction based on the different weak models predictions" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "![](img/ensemble1.png)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "![](img/ensemble2.png)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### XGBoost" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "XGBoost is an implementation of gradient boosted decision trees designed for speed and performance." + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "metadata": {}, + "outputs": [], + "source": [ + "import xgboost as xgb" + ] + }, + { + "cell_type": "code", + "execution_count": 32, + "metadata": {}, + "outputs": [], + "source": [ + "dmatrix_train = xgb.DMatrix(data=X_train, label=y_train)\n", + "dmatrix_test = xgb.DMatrix(data=X_test, label=y_test)" + ] + }, + { + "cell_type": "code", + "execution_count": 64, + "metadata": {}, + "outputs": [], + "source": [ + "param = {'max_depth':3, \n", + " 'eta':1, \n", + " 'objective':'multi:softprob', \n", + " 'num_class':3}\n", + "\n", + "num_round = 5\n", + "model = xgb.train(param, dmatrix_train, num_round)" + ] + }, + { + "cell_type": "code", + "execution_count": 65, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[0.0046 , 0.9871078 , 0.00829213],\n", + " [0.00398089, 0.00646372, 0.9895555 ],\n", + " [0.00398902, 0.0044349 , 0.99157614],\n", + " [0.00387317, 0.9924493 , 0.00367761],\n", + " [0.9892699 , 0.00651816, 0.00421197],\n", + " [0.04196233, 0.5648941 , 0.39314362],\n", + " [0.0046 , 0.9871078 , 0.00829213],\n", + " [0.9892699 , 0.00651816, 0.00421197],\n", + " [0.9892699 , 0.00651816, 0.00421197],\n", + " [0.0038679 , 0.9910994 , 0.00503268]], dtype=float32)" + ] + }, + "execution_count": 65, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "preds = model.predict(dmatrix_test)\n", + "preds[:10]" + ] + }, + { + "cell_type": "code", + "execution_count": 66, + "metadata": {}, + "outputs": [], + "source": [ + "best_preds = np.asarray([np.argmax(line) for line in preds])" + ] + }, + { + "cell_type": "code", + "execution_count": 67, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([1, 2, 2, 1, 0, 1, 1, 0, 0, 1, 2, 0, 1, 2, 2, 2, 0, 0, 1, 0, 0, 1,\n", + " 0, 2, 0, 0, 0, 2, 2, 0, 2, 1, 0, 0, 1, 1, 2, 0, 0, 1, 1, 0, 2, 2,\n", + " 2, 2, 2, 1, 0, 0], dtype=int64)" + ] + }, + "execution_count": 67, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "best_preds" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Metrics" + ] + }, + { + "cell_type": "code", + "execution_count": 68, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Precision = 0.9285714285714285\n", + "Recall = 0.9473684210526315\n", + "Accuracy = 0.94\n" + ] + } + ], + "source": [ + "print(\"Precision = {}\".format(precision_score(y_test, best_preds, average='macro')))\n", + "print(\"Recall = {}\".format(recall_score(y_test, best_preds, average='macro')))\n", + "print(\"Accuracy = {}\".format(accuracy_score(y_test, best_preds)))" + ] + }, + { + "cell_type": "code", + "execution_count": 69, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "from sklearn.metrics import confusion_matrix\n", + "\n", + "plt.figure(figsize=(12, 8))\n", + "cm = confusion_matrix(y_test, best_preds)\n", + "ax = sns.heatmap(cm, square=True, annot=True, cbar=False)\n", + "ax.xaxis.set_ticklabels(categories, fontsize = 12)\n", + "ax.yaxis.set_ticklabels(categories, fontsize = 12, rotation=0)\n", + "ax.set_xlabel('Predicted Labels',fontsize = 15)\n", + "ax.set_ylabel('True Labels',fontsize = 15)\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 34, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Tuned: {'learning_rate': 0.001, 'max_depth': 3, 'min_child_weight': 1, 'n_estimators': 200}\n", + "Mean of the cv scores is 0.930000\n", + "Train Score 0.970000\n", + "Test Score 0.960000\n", + "Seconds used for refitting the best model on the train dataset: 0.157686\n" + ] + } + ], + "source": [ + "## Hyperparameter Tuning\n", + "\n", + "from xgboost.sklearn import XGBClassifier\n", + "from sklearn.model_selection import GridSearchCV, RandomizedSearchCV \n", + "\n", + "param_dict = {\n", + " 'max_depth':range(3,10,2),\n", + " 'min_child_weight':range(1,6,2),\n", + " 'learning_rate': [0.001,0.01,0.1,1],\n", + " 'n_estimators': [200,500,1000]\n", + " \n", + "}\n", + "\n", + "xgc = XGBClassifier(booster='gbtree', learning_rate =0.01, n_estimators=200, max_depth=5,\n", + " min_child_weight=1, gamma=0, subsample=0.8, colsample_bytree=0.8,\n", + " objective= 'multi:softprob', nthread=4, scale_pos_weight=1, seed=27)\n", + "\n", + "clf = GridSearchCV(xgc,param_dict,cv=2,n_jobs = -1).fit(X_train,y_train)\n", + "\n", + "print(\"Tuned: {}\".format(clf.best_params_)) \n", + "print(\"Mean of the cv scores is {:.6f}\".format(clf.best_score_))\n", + "print(\"Train Score {:.6f}\".format(clf.score(X_train,y_train)))\n", + "print(\"Test Score {:.6f}\".format(clf.score(X_test,y_test)))\n", + "print(\"Seconds used for refitting the best model on the train dataset: {:.6f}\".format(clf.refit_time_))" + ] + }, + { + "cell_type": "code", + "execution_count": 36, + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plt.figure(figsize=(12, 8))\n", + "\n", + "xgb_pred = clf.predict(X_test)\n", + "cm = confusion_matrix(y_test, xgb_pred)\n", + "ax = sns.heatmap(cm, square=True, annot=True, cbar=False)\n", + "ax.xaxis.set_ticklabels(categories, fontsize = 12)\n", + "ax.yaxis.set_ticklabels(categories, fontsize = 12, rotation=0)\n", + "ax.set_xlabel('Predicted Labels',fontsize = 15)\n", + "ax.set_ylabel('True Labels',fontsize = 15)\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Resources\n", + "\n", + "https://towardsai.net/p/programming/decision-trees-explained-with-a-practical-example-fe47872d3b53\n", + "https://towardsdatascience.com/decision-trees-in-machine-learning-641b9c4e8052 \n", + "https://towardsdatascience.com/visualizing-decision-trees-with-python-scikit-learn-graphviz-matplotlib-1c50b4aa68dc\n", + "https://www.analyticsvidhya.com/blog/2016/03/complete-guide-parameter-tuning-xgboost-with-codes-python/ \n" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.7.3" + }, + "toc": { + "base_numbering": 1, + "nav_menu": {}, + "number_sections": true, + "sideBar": true, + "skip_h1_title": false, + "title_cell": "Table of Contents", + "title_sidebar": "Contents", + "toc_cell": false, + "toc_position": {}, + "toc_section_display": true, + "toc_window_display": false + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/Decision Trees/decision_trees.ipynb b/Decision Trees/decision_trees.ipynb index 13b5e38..d1a0477 100644 --- a/Decision Trees/decision_trees.ipynb +++ b/Decision Trees/decision_trees.ipynb @@ -1090,205 +1090,19 @@ }, { "cell_type": "code", - "execution_count": 24, + "execution_count": 1, "metadata": {}, "outputs": [ { - "data": { - "image/svg+xml": [ - "\r\n", - "\r\n", - "\r\n", - "\r\n", - "\r\n", - "\r\n", - "Tree\r\n", - "\r\n", - "\r\n", - "0\r\n", - "\r\n", - "PetalLengthCm <= 2.45\r\n", - "gini = 0.662\r\n", - "samples = 100\r\n", - "value = [30, 39, 31]\r\n", - "class = Iris-versicolor\r\n", - "\r\n", - "\r\n", - "1\r\n", - "\r\n", - "gini = 0.0\r\n", - "samples = 30\r\n", - "value = [30, 0, 0]\r\n", - "class = Iris-setosa\r\n", - "\r\n", - "\r\n", - "0->1\r\n", - "\r\n", - "\r\n", - "True\r\n", - "\r\n", - "\r\n", - "2\r\n", - "\r\n", - "PetalWidthCm <= 1.75\r\n", - "gini = 0.493\r\n", - "samples = 70\r\n", - "value = [0, 39, 31]\r\n", - "class = Iris-versicolor\r\n", - "\r\n", - "\r\n", - "0->2\r\n", - "\r\n", - "\r\n", - "False\r\n", - "\r\n", - "\r\n", - "3\r\n", - "\r\n", - "PetalLengthCm <= 5.35\r\n", - "gini = 0.136\r\n", - "samples = 41\r\n", - "value = [0, 38, 3]\r\n", - "class = Iris-versicolor\r\n", - "\r\n", - "\r\n", - "2->3\r\n", - "\r\n", - "\r\n", - "\r\n", - "\r\n", - "8\r\n", - "\r\n", - "PetalLengthCm <= 4.85\r\n", - "gini = 0.067\r\n", - "samples = 29\r\n", - "value = [0, 1, 28]\r\n", - "class = Iris-virginica\r\n", - "\r\n", - "\r\n", - "2->8\r\n", - "\r\n", - "\r\n", - "\r\n", - "\r\n", - "4\r\n", - "\r\n", - "SepalLengthCm <= 5.0\r\n", - "gini = 0.05\r\n", - "samples = 39\r\n", - "value = [0, 38, 1]\r\n", - "class = Iris-versicolor\r\n", - "\r\n", - "\r\n", - "3->4\r\n", - "\r\n", - "\r\n", - "\r\n", - "\r\n", - "7\r\n", - "\r\n", - "gini = 0.0\r\n", - "samples = 2\r\n", - "value = [0, 0, 2]\r\n", - "class = Iris-virginica\r\n", - "\r\n", - "\r\n", - "3->7\r\n", - "\r\n", - "\r\n", - "\r\n", - "\r\n", - "5\r\n", - "\r\n", - "gini = 0.5\r\n", - "samples = 2\r\n", - "value = [0, 1, 1]\r\n", - "class = Iris-versicolor\r\n", - "\r\n", - "\r\n", - "4->5\r\n", - "\r\n", - "\r\n", - "\r\n", - "\r\n", - "6\r\n", - "\r\n", - "gini = 0.0\r\n", - "samples = 37\r\n", - "value = [0, 37, 0]\r\n", - "class = Iris-versicolor\r\n", - "\r\n", - "\r\n", - "4->6\r\n", - "\r\n", - "\r\n", - "\r\n", - "\r\n", - "9\r\n", - "\r\n", - "SepalWidthCm <= 3.0\r\n", - "gini = 0.5\r\n", - "samples = 2\r\n", - "value = [0, 1, 1]\r\n", - "class = Iris-versicolor\r\n", - "\r\n", - "\r\n", - "8->9\r\n", - "\r\n", - "\r\n", - "\r\n", - "\r\n", - "12\r\n", - "\r\n", - "gini = 0.0\r\n", - "samples = 27\r\n", - "value = [0, 0, 27]\r\n", - "class = Iris-virginica\r\n", - "\r\n", - "\r\n", - "8->12\r\n", - "\r\n", - "\r\n", - "\r\n", - "\r\n", - "10\r\n", - "\r\n", - "gini = 0.0\r\n", - "samples = 1\r\n", - "value = [0, 0, 1]\r\n", - "class = Iris-virginica\r\n", - "\r\n", - "\r\n", - "9->10\r\n", - "\r\n", - "\r\n", - "\r\n", - "\r\n", - "11\r\n", - "\r\n", - "gini = 0.0\r\n", - "samples = 1\r\n", - "value = [0, 1, 0]\r\n", - "class = Iris-versicolor\r\n", - "\r\n", - "\r\n", - "9->11\r\n", - "\r\n", - "\r\n", - "\r\n", - "\r\n", - "\r\n" - ], - "text/plain": [ - "" - ] - }, - "execution_count": 24, - "metadata": {}, - "output_type": "execute_result" + "ename": "ModuleNotFoundError", + "evalue": "No module named 'graphviz'", + "output_type": "error", + "traceback": [ + "\u001b[1;31m----------------------------------------------------------------------\u001b[0m", + "\u001b[1;31mModuleNotFoundError\u001b[0m Traceback (most recent call last)", + "\u001b[1;32m\u001b[0m in \u001b[0;36m\u001b[1;34m\u001b[0m\n\u001b[0;32m 6\u001b[0m \u001b[0mos\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0menviron\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;34m\"PATH\"\u001b[0m\u001b[1;33m]\u001b[0m \u001b[1;33m+=\u001b[0m \u001b[1;34m';'\u001b[0m \u001b[1;33m+\u001b[0m \u001b[1;34mr'C:\\Users\\Dell\\Anaconda3\\Library\\bin\\graphviz'\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 7\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 8\u001b[1;33m \u001b[1;32mimport\u001b[0m \u001b[0mgraphviz\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m 9\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 10\u001b[0m dot_data = export_graphviz(clf, out_file=None,\n", + "\u001b[1;31mModuleNotFoundError\u001b[0m: No module named 'graphviz'" + ] } ], "source": [ @@ -1742,7 +1556,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.7.3" + "version": "3.7.9" }, "toc": { "base_numbering": 1, diff --git a/Linear Algebra/.ipynb_checkpoints/Linear_Algebra-checkpoint.ipynb b/Linear Algebra/.ipynb_checkpoints/Linear_Algebra-checkpoint.ipynb new file mode 100644 index 0000000..f618fe2 --- /dev/null +++ b/Linear Algebra/.ipynb_checkpoints/Linear_Algebra-checkpoint.ipynb @@ -0,0 +1,1142 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + " \"Open\n", + "" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "bf15tCVlEoqh" + }, + "source": [ + "![](img/logo.png)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "VrIbtuS4Eoqj" + }, + "source": [ + "
All rights reserved ©️ Global AI Hub 2020
" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "q8svL2FUEoqj" + }, + "source": [ + "# Linear Algebra Review" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "9CvXqHtHEoqk" + }, + "source": [ + "![](img/linear.png)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "CiRWYak3Eoqk" + }, + "source": [ + "- **Scalar:** Any single numerical value.\n", + "- **Vector:** An array of numbers(data) is a vector. \n", + "- **Matrix:** A matrix is a 2-D array of shape $(m×n)$ with m rows and n columns.\n", + "- **Tensor:** Generally, an n-dimensional array where n>2 is called a Tensor. But a matrix or a vector is also a valid tensor." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "id": "PNp4ZvkmEoql" + }, + "outputs": [], + "source": [ + "import numpy as np" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "2" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "Ljn54A0PEoqo" + }, + "source": [ + "### Creating Vector" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 35 + }, + "id": "cViwMQZBEoqp", + "outputId": "c4e9d558-5d85-4c91-f551-9fa46d1b24ca" + }, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[1, 2, 3, 4, 5]])" + ] + }, + "execution_count": 2, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "arr_1 = np.array([1,2,3,4,5],ndmin=2)\n", + "arr_1" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 70 + }, + "id": "Ao_Wzw91Eoqs", + "outputId": "55d3af02-eb22-4f57-80b9-17922a09ebbf" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Type: \n", + "Shape: (1, 5)\n", + "Dimension: 2\n" + ] + } + ], + "source": [ + "print(f\"Type: {type(arr_1)}\")\n", + "print(f\"Shape: {arr_1.shape}\")\n", + "print(f\"Dimension: {arr_1.ndim}\")" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "hu32zcsKEoqv" + }, + "source": [ + "### Creating Matrix" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 52 + }, + "id": "Az4Es5XOEoqw", + "outputId": "38c31156-fb98-49e8-939a-1381b33e8ad4" + }, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[1, 2, 3, 4],\n", + " [5, 6, 7, 8]])" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "arr_2 = np.array([[1,2,3,4],\n", + " [5,6,7,8]]) \n", + "arr_2" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 70 + }, + "id": "WiraowZLEoqz", + "outputId": "96989ebd-1b60-46c9-f256-abecfc65a4de" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Type: \n", + "Shape: (2, 4)\n", + "Dimension: 2\n" + ] + } + ], + "source": [ + "print(f\"Type: {type(arr_2)}\")\n", + "print(f\"Shape: {arr_2.shape}\")\n", + "print(f\"Dimension: {arr_2.ndim}\")" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "nXHAX7y5Eoq1" + }, + "source": [ + "# Addition and Scalar Multiplication " + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "gW4wg1S9Eoq2" + }, + "source": [ + "## Addition" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "qkhyl2G9Eoq2" + }, + "source": [ + " Two matrices may be added or subtracted only if they have the same dimension ( $ m_1$ x $n_1$ = $m_2$ x $n_2$ ); that is, they must have the same number of rows and columns. Addition or subtraction is accomplished by adding or subtracting corresponding elements.\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 248 + }, + "id": "K3J25dgJEoq3", + "outputId": "e2aaaeb4-d64e-49d0-e39e-227ff22b5e47" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Matrice_1: \n", + "[[1 2 3 4]\n", + " [5 6 7 8]\n", + " [9 8 6 5]] \n", + "\n", + "Shape of Matrice 1: (3, 4)\n", + "\n", + "Matrice_2: \n", + "[[-1 4 3 5]\n", + " [ 1 4 7 9]\n", + " [-6 5 11 -4]] \n", + "\n", + "Shape of Matrice 2: (3, 4)\n" + ] + } + ], + "source": [ + "matrice_1 = np.array([[1, 2, 3, 4], \n", + " [5, 6, 7, 8], \n", + " [9, 8, 6, 5]])\n", + "\n", + "matrice_2 = np.array([[-1, 4, 3, 5],\n", + " [1, 4, 7, 9],\n", + " [-6, 5, 11, -4]])\n", + "\n", + "print(f\"Matrice_1: \\n{matrice_1}\",\"\\n\")\n", + "print(f\"Shape of Matrice 1: {matrice_1.shape}\")\n", + "print(f\"\\nMatrice_2: \\n{matrice_2}\",\"\\n\")\n", + "print(f\"Shape of Matrice 2: {matrice_2.shape}\")" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "FoEH4I5-Eoq6" + }, + "source": [ + "### Adding two matrices" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 70 + }, + "id": "bvT8Xe-JEoq7", + "outputId": "db7f66c5-2de6-4007-cd5a-ee0f816e7e8e" + }, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[ 0, 6, 6, 9],\n", + " [ 6, 10, 14, 17],\n", + " [ 3, 13, 17, 1]])" + ] + }, + "execution_count": 23, + "metadata": { + "tags": [] + }, + "output_type": "execute_result" + } + ], + "source": [ + "matrice_1 + matrice_2" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "XV0SqgErEoq9" + }, + "source": [ + "---" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "pVDK5TrSEoq9" + }, + "source": [ + "## Multiplication" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "tHBac_SaEoq-" + }, + "source": [ + "### Scalar Multiplication" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "0QL9SKeaEoq-" + }, + "source": [ + " The term scalar multiplication refers to the product of a real number and a matrix. In scalar multiplication, each entry in the matrix is multiplied by the given scalar." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 70 + }, + "id": "K5fgYct3Eoq-", + "outputId": "dd24ce18-272e-466d-e60a-df2157fff632" + }, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[ -1, 8, 9, 20],\n", + " [ 5, 24, 49, 72],\n", + " [-54, 40, 66, -20]])" + ] + }, + "execution_count": 28, + "metadata": { + "tags": [] + }, + "output_type": "execute_result" + } + ], + "source": [ + "matrice_1 * matrice_2" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "KN_oC5TqEorC" + }, + "source": [ + "### Matrix-Vector Multiplication " + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "vffZaAAIEorC" + }, + "source": [ + " Multiplication between a matrix \"M\" and a vector \"v\", we need to view the vector as a column matrix. We define the matrix-vector product only for the case when the number of columns in M equals the number of rows in v. So, if M is an m×n matrix (i.e., with n columns), then the product $M.v$ is defined for $n$ × $1$ column vectors x. If we let $M.v=r$, then $r$ is an $m$ x $1$ column vector. \n", + "\n", + " $$ (m\\;,\\;n)\\;\\;.\\;(n\\;,\\;1) = (m\\;,\\;1) $$" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 52 + }, + "id": "SDRAq70xEorC", + "outputId": "a843336c-b7a2-4b51-f991-f351523becda" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Shape of matrix M = (3, 3) \n", + " Shape of vector v = (3,)\n" + ] + } + ], + "source": [ + "M = np.array([[ 6, 1 ,3], \n", + " [ -1, 1 ,1], \n", + " [ 1, 3 ,2]])\n", + "\n", + "#Rank 1 array\n", + "v = np.array([1, 2, 3])\n", + "\n", + "print(f\"Shape of matrix M = {M.shape}\",\"\\n\",f\"Shape of vector v = {v.shape}\")" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "4" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "-1*1 + 2*1 + 3*1" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "tyLcx6rBEorF" + }, + "source": [ + "#### Option 1:" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 35 + }, + "id": "16x8wmcuEorF", + "outputId": "4869b4ab-8ea8-48e1-8c89-5e98dfaaf7d8" + }, + "outputs": [ + { + "data": { + "text/plain": [ + "array([17, 4, 13])" + ] + }, + "execution_count": 24, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "M.dot(v)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "hUZ5F8EIEorI" + }, + "source": [ + "#### Option 2:" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 35 + }, + "id": "T-arc6Q8EorI", + "outputId": "19336582-670d-40ee-d6c9-6084076ce85a" + }, + "outputs": [ + { + "data": { + "text/plain": [ + "array([17, 4, 13])" + ] + }, + "execution_count": 25, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "np.dot(M,v)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "zVo3plssEorK" + }, + "source": [ + "### Matrix-Matrix Multiplication " + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "IEzl_dSIEorK" + }, + "source": [ + "Matrix-Matrix multiplication, the number of columns in the first matrix must be equal to the number of rows in the second matrix. The resulting matrix, known as the matrix product, has the number of rows of the first and the number of columns of the second matrix.\n", + "\n", + "$$ n_1 = m_2$$\n" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 52 + }, + "id": "bXA0BKPLEorL", + "outputId": "4356a204-5158-4dfa-9466-16ca06eecf6e" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Shape of matrix C = (3, 4) \n", + " Shape of vector D = (4, 3)\n", + "[[-1 4 3]\n", + " [ 5 1 4]\n", + " [ 7 9 -6]\n", + " [ 5 11 -4]]\n" + ] + } + ], + "source": [ + "C = np.array([[1, 2, 3, 4],\n", + " [5, 6, 7, 8],\n", + " [9, 8, 6, 5]])\n", + "\n", + "D = np.array([[-1, 4, 3, 5],\n", + " [1, 4, 7, 9],\n", + " [-6, 5, 11, -4]]).reshape(4,3)\n", + "\n", + "print(f\"Shape of matrix C = {C.shape}\",\"\\n\",f\"Shape of vector D = {D.shape}\")\n", + "print(D)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 70 + }, + "id": "6kzkltUSEorN", + "outputId": "72e657cf-af21-41d0-9663-ba949eb080a3" + }, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[ 50, 77, -23],\n", + " [114, 177, -35],\n", + " [ 98, 153, 3]])" + ] + }, + "execution_count": 50, + "metadata": { + "tags": [] + }, + "output_type": "execute_result" + } + ], + "source": [ + "C.dot(D)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 70 + }, + "id": "-FTm0NADEorP", + "outputId": "66bc24b1-e2da-4278-b132-8ea4dc344700" + }, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[ 50, 77, -23],\n", + " [114, 177, -35],\n", + " [ 98, 153, 3]])" + ] + }, + "execution_count": 51, + "metadata": { + "tags": [] + }, + "output_type": "execute_result" + } + ], + "source": [ + "np.dot(C,D)" + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[46, 46, 43, 43],\n", + " [46, 48, 46, 48],\n", + " [-2, 20, 48, 70],\n", + " [24, 44, 68, 88]])" + ] + }, + "execution_count": 27, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "np.dot(D,C)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "ncrKTCv7EorV" + }, + "source": [ + "## Matrix Multiplication Properties" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "hRgUcHmQEorV" + }, + "source": [ + "1. The commutative property of multiplication $AB \\neq BA$\n", + "\n", + "2. Associative property of multiplication $(AB)C = A(BC)$\n", + "\n", + "3. Distributive properties $A(B+C) = AB+AC$\n", + "\n", + "4. Multiplicative identity property $ IA =A\\, \\& \\, AI=A$\n", + "\n", + "5. Multiplicative property of zero $ I0 =0 \\, \\& \\, A0=0$\n", + "\n", + "6. Dimension property" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "w2anp9PQEorW" + }, + "source": [ + "# Inverse and Transpose" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "IHCTLSUpEorW" + }, + "source": [ + "## Inverse" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "Wp-bJiKnEorX" + }, + "source": [ + "In linear algebra, an n-by-n square matrix A is called invertible (also nonsingular or nondegenerate), if there exists an n-by-n square matrix B such that\n", + "\n", + "$ AB=BA=I $ where In denotes the n-by-n identity matrix and the multiplication used is ordinary matrix multiplication. If this is the case, then the matrix B is uniquely determined by A, and is called the (multiplicative) inverse of A, denoted by A−1.\n", + "\n", + " $$A\\;.\\; A^{-1} = I $$\n", + "Where: \n", + "$I$: Identity Matrix \n", + "Shape A: $ (n,n)$ " + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 70 + }, + "id": "pvHq_cv6RBCn", + "outputId": "ee88e630-ed95-42fa-fc79-1344db14b219" + }, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[1., 0., 0.],\n", + " [0., 1., 0.],\n", + " [0., 0., 1.]])" + ] + }, + "execution_count": 80, + "metadata": { + "tags": [] + }, + "output_type": "execute_result" + } + ], + "source": [ + "#Example of identity matrix with 3 x 3 dimension\n", + "np.identity(3)" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": { + "id": "8SvZ5NFnEorX" + }, + "outputs": [], + "source": [ + "x = np.array([[6, 9],\n", + " [12, 17]])\n", + "\n", + "y = np.array([[8, 5],\n", + " [1, 2]])" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(2, 2)" + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "y.shape" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": { + "id": "oeaaSv9SEorZ" + }, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[-2.83333333, 1.5 ],\n", + " [ 2. , -1. ]])" + ] + }, + "execution_count": 11, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "x_inv = np.linalg.inv(x)\n", + "x_inv" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 52 + }, + "id": "F-nZz--VP7T4", + "outputId": "a28c2018-5ae0-4b4d-a294-0a05443e11fd" + }, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[1., 0.],\n", + " [0., 1.]])" + ] + }, + "execution_count": 12, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "x.dot(x_inv)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "BTOGBPgeEord" + }, + "source": [ + "## Transpose" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "22WuaRLnEord" + }, + "source": [ + "In linear algebra, the transpose of a matrix is an operator which flips a matrix over its diagonal; that is, it switches the row and column indices of the matrix $A$ by producing another matrix, often denoted by $A^T$(among other notations).\n", + "\n", + "If matrix A's shape is $(n,m)$, then shape of $A^T$ will be shape of $(m,n)$" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 52 + }, + "id": "5WK1OEQDEord", + "outputId": "54db8416-1fa2-4eda-e64e-8f4f8f55a9eb" + }, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[ 6, 9],\n", + " [12, 17]])" + ] + }, + "execution_count": 13, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "x" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 52 + }, + "id": "989rBTm7Eorf", + "outputId": "c6762853-0c18-43a7-9e09-b8c6eea471a9" + }, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[ 6, 12],\n", + " [ 9, 17]])" + ] + }, + "execution_count": 14, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "x_trans = x.T\n", + "x_trans" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[1, 5, 9],\n", + " [2, 6, 8],\n", + " [3, 7, 6],\n", + " [4, 8, 5]])" + ] + }, + "execution_count": 16, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "C.T" + ] + }, + { + "cell_type": "code", + "execution_count": 39, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 159 + }, + "id": "0nfN6Dq8Eori", + "outputId": "645541ae-1d0b-42d6-b63d-17e6c8db32aa" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Matrice: \n", + "[[6 1 2]\n", + " [5 2 3]\n", + " [3 5 9]\n", + " [1 7 1]\n", + " [5 2 6]]\n", + "\n", + "Shape: (5, 3)\n" + ] + } + ], + "source": [ + "A = np.random.randint(1, 10, size=(5, 3))\n", + "\n", + "print(f\"Matrice: \\n{A}\")\n", + "print(f\"\\nShape: {A.shape}\")" + ] + }, + { + "cell_type": "code", + "execution_count": 79, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 159 + }, + "id": "s5CBacjkSOGj", + "outputId": "196467e0-b123-4f59-9d9e-2885aff1e180" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Matrice: \n", + "[[5 5 1]\n", + " [7 7 3]\n", + " [4 1 9]\n", + " [9 8 5]\n", + " [9 7 9]]\n", + "\n", + "Shape: (5, 3)\n" + ] + } + ], + "source": [ + "#Seed\n", + "np.random.seed(5)\n", + "\n", + "A = np.random.randint(1, 10, size=(5, 3))\n", + "\n", + "print(f\"Matrice: \\n{A}\")\n", + "print(f\"\\nShape: {A.shape}\")" + ] + }, + { + "cell_type": "code", + "execution_count": 85, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[62, 85, 20],\n", + " [45, 88, 71],\n", + " [52, 33, 98],\n", + " [53, 60, 68],\n", + " [78, 46, 67]])" + ] + }, + "execution_count": 85, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "np.random.seed()\n", + "\n", + "A = np.random.randint(1, 10, size=(5, 3))\n", + "\n", + "B = np.random.randint(17, 100, size=(5, 3))\n", + "\n", + "A + B" + ] + }, + { + "cell_type": "code", + "execution_count": 51, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 124 + }, + "id": "3196zyn2Eork", + "outputId": "4cee206e-b4f0-4fd3-ee9a-26591c8c55f4" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Matrice: \n", + "[[4 5 9 4 1]\n", + " [9 8 8 1 3]\n", + " [5 2 4 4 9]]\n", + "\n", + "Shape: (3, 5)\n" + ] + } + ], + "source": [ + "A_t = A.T\n", + "\n", + "print(f\"Matrice: \\n{A_t}\")\n", + "print(f\"\\nShape: {A_t.shape}\")" + ] + }, + { + "cell_type": "code", + "execution_count": 80, + "metadata": { + "id": "Gg7E0F_7Eorm" + }, + "outputs": [], + "source": [ + "np.random.seed()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "zBORL4KGEoro" + }, + "outputs": [], + "source": [] + } + ], + "metadata": { + "colab": { + "collapsed_sections": [], + "name": "Linear_Algebra.ipynb", + "provenance": [] + }, + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.7.3" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/Linear Algebra/Linear_Algebra.ipynb b/Linear Algebra/Linear_Algebra.ipynb index f618fe2..fad87ce 100644 --- a/Linear Algebra/Linear_Algebra.ipynb +++ b/Linear Algebra/Linear_Algebra.ipynb @@ -1134,7 +1134,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.7.3" + "version": "3.7.9" } }, "nbformat": 4, diff --git a/Linear Regression/.ipynb_checkpoints/linear_regression-checkpoint.ipynb b/Linear Regression/.ipynb_checkpoints/linear_regression-checkpoint.ipynb new file mode 100644 index 0000000..31ec2ef --- /dev/null +++ b/Linear Regression/.ipynb_checkpoints/linear_regression-checkpoint.ipynb @@ -0,0 +1,2131 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + " \"Open\n", + "" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "colab_type": "text", + "id": "PIBzTWnCk94D" + }, + "source": [ + " All rights reserved © Global AI Hub 2020 \n", + "![](img/logo.png)\n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "colab_type": "text", + "id": "xAFYL8FOC3EX" + }, + "source": [ + "# What is Regression?" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "colab_type": "text", + "id": "ObZajM_LDfze" + }, + "source": [ + "Regression analysis is one of the most important fields in statistics and machine learning. There are many regression methods available. Linear regression is one of them." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "colab_type": "text", + "id": "tp0RCvw-D0jq" + }, + "source": [ + "Regression searches for relationships among variables. For example, you can observe several employees of some company and try to understand how their salaries depend on the features, such as experience, level of education, role, city they work in, and so on." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "colab_type": "text", + "id": "t7TUcDz4HyB4" + }, + "source": [ + "# Linear Regression" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "colab_type": "text", + "id": "pcJ2U0sUIAzn" + }, + "source": [ + "Linear regression is probably one of the most important and widely used regression techniques. It’s among the simplest regression methods. One of its main advantages is the ease of interpreting results." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "colab_type": "text", + "id": "Fh3LdXkTI2Ns" + }, + "source": [ + "When implementing linear regression of some dependent variable 𝑦 on the set of independent variables 𝐱 = (𝑥₁, …, 𝑥ᵣ), where 𝑟 is the number of predictors, you assume a linear relationship between 𝑦 and 𝐱: 𝑦 = 𝛽₀ + 𝛽₁𝑥₁ + ⋯ + 𝛽ᵣ𝑥ᵣ + 𝜀. This equation is the regression equation. 𝛽₀, 𝛽₁, …, 𝛽ᵣ are the regression coefficients, and 𝜀 is the random error." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "colab_type": "text", + "id": "gBea82xsJZuh" + }, + "source": [ + "## Simple Linear Regression" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "colab_type": "text", + "id": "CDXdTosaJfFJ" + }, + "source": [ + "Simple or single-variate linear regression is the simplest case of linear regression with a single independent variable, 𝐱 = x. " + ] + }, + { + "cell_type": "markdown", + "metadata": { + "colab_type": "text", + "id": "HJMakg8FJ0oi" + }, + "source": [ + "![image.png](data:image/png;base64,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)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "colab_type": "text", + "id": "DesNbbSCK7iA" + }, + "source": [ + "The estimated regression function (red line) has the equation:\n", + "$$f(x) = b_o + 𝑏_1x$$ \n", + "\n", + "Our goal is to calculate the optimal values of the predicted weights 𝑏₀ and 𝑏₁ that minimize the sum of squared residuals (SSR) and determine the estimated regression function." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "colab_type": "text", + "id": "cBlpRHffLQTp" + }, + "source": [ + "## Multiple Linear Regression" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "colab_type": "text", + "id": "JTXLFFmILXvG" + }, + "source": [ + "Multiple or multivariate linear regression is a case of linear regression with two or more independent variables.\n", + "\n", + "If there are just two independent variables, the estimated regression function is: \n", + "$$f(x_1,x_2) = b_0 + b_1x_1 + b_2x_2$$\n", + "It represents a regression plane in a three-dimensional space. The goal of regression is to determine the values of the weights 𝑏₀, 𝑏₁, and 𝑏₂ such that this plane is as close as possible to the actual responses and yield the minimal SSR." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "![](img/lin1.png)\n", + "\n", + "

Plane

" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "colab_type": "text", + "id": "nM-uW1kShW0b" + }, + "source": [ + "## Polynomial Regression" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "colab_type": "text", + "id": "SrKnG8HMhZE3" + }, + "source": [ + "You can regard polynomial regression as a generalized case of linear regression. You assume the polynomial dependence between the output and inputs and, consequently, the polynomial estimated regression function.\n", + "\n", + "In other words, in addition to linear terms like 𝑏₁𝑥₁, your regression function 𝑓 can include non-linear terms such as 𝑏₂𝑥₁², 𝑏₃𝑥₁³, or even 𝑏₄𝑥₁𝑥₂, 𝑏₅𝑥₁²𝑥₂, and so on.\n", + "\n", + "\n", + "The simplest example of polynomial regression has a single independent variable, and the estimated regression function is a polynomial of degree 2:\n", + "$$ f(x) = b_o + b_1x + b_2x^2$$\n", + "\n", + "- Kernel Trick\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Regression Assumptions \n", + "\n", + "### Linearity\n", + "\n", + "The simple meaning of linearity is understand from scatter plot which is the straight line that drawn in between points on scatter plot.\n", + "\n", + "### No Heteroskedasticity\n", + "The presence of non-constant variance in the error terms results in heteroskedasticity \n", + "\n", + "**Residual Data**: The residual data of the simple linear regression model is the difference between the observed data of the dependent variable y and the fitted values ŷ. \n", + "` plt.scatter(pred, (pred - actual), c='b')`\n", + "![](img/residual-plot.png)\n", + "\n", + "### No Multi-Colinearity\n", + "Multicollinearity refers to a situation in which two or more explanatory variables in a multiple regression model are highly linearly related. \n", + " \n", + "How to identify this:\n", + "- Using Pearson-correlation.
\n", + "\n", + "How to fix this: \n", + "- Drop one of the two variables \n", + "- Create a function to create a new independent variable using the correlated features and drop the correlated features." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "colab_type": "text", + "id": "QrisOngVj_Gm" + }, + "source": [ + "## Simple Linear Regression With scikit-learn" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "colab_type": "text", + "id": "dwT8MuDxmi8v" + }, + "source": [ + "### Import the Packages" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "colab": {}, + "colab_type": "code", + "id": "LQUftsJ6C0e1" + }, + "outputs": [], + "source": [ + "import numpy as np\n", + "from sklearn.linear_model import LinearRegression" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "colab_type": "text", + "id": "8FrcERYtmqOW" + }, + "source": [ + "### Provide Data" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 141 + }, + "colab_type": "code", + "executionInfo": { + "elapsed": 946, + "status": "ok", + "timestamp": 1600455328617, + "user": { + "displayName": "Adem Tekin", + "photoUrl": "https://lh3.googleusercontent.com/a-/AOh14Gjji3ec_q6_sWOPCSacyEQOavzHeGZCtJpnBwD9=s64", + "userId": "01835850446278926637" + }, + "user_tz": -180 + }, + "id": "FqECs48CC0Tg", + "outputId": "8a823499-d4ad-4da9-c550-76783a1486d3" + }, + "outputs": [], + "source": [ + "from sklearn.datasets import make_regression\n", + "X, y = make_regression(n_samples=100, n_features=1, noise=5,random_state=42)" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "import matplotlib.pyplot as plt" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plt.scatter(X, y)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "colab_type": "text", + "id": "7lgOFL7xmw6I" + }, + "source": [ + "### Create a model & fit" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": { + "colab": {}, + "colab_type": "code", + "id": "c9pvWB2xC0HP" + }, + "outputs": [], + "source": [ + "model = LinearRegression()" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 34 + }, + "colab_type": "code", + "executionInfo": { + "elapsed": 907, + "status": "ok", + "timestamp": 1600455412483, + "user": { + "displayName": "Adem Tekin", + "photoUrl": "https://lh3.googleusercontent.com/a-/AOh14Gjji3ec_q6_sWOPCSacyEQOavzHeGZCtJpnBwD9=s64", + "userId": "01835850446278926637" + }, + "user_tz": -180 + }, + "id": "Z6ZSZku6Cz7p", + "outputId": "8eb7e5e0-3468-466b-d940-a3ac54703ce6" + }, + "outputs": [ + { + "data": { + "text/plain": [ + "LinearRegression(copy_X=True, fit_intercept=True, n_jobs=None, normalize=False)" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "model.fit(X, y)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "colab_type": "text", + "id": "sooWWsmqm6RP" + }, + "source": [ + "### Get Results" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 34 + }, + "colab_type": "code", + "executionInfo": { + "elapsed": 1004, + "status": "ok", + "timestamp": 1600455441876, + "user": { + "displayName": "Adem Tekin", + "photoUrl": "https://lh3.googleusercontent.com/a-/AOh14Gjji3ec_q6_sWOPCSacyEQOavzHeGZCtJpnBwD9=s64", + "userId": "01835850446278926637" + }, + "user_tz": -180 + }, + "id": "mFxmTaseCzu_", + "outputId": "ff14a536-3cf6-4608-f92c-a607bef255d3" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Coefficient of determination (R2): 0.9872919587211264\n" + ] + } + ], + "source": [ + "r_sq = model.score(X, y)\n", + "print('Coefficient of determination (R2):', r_sq)" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 52 + }, + "colab_type": "code", + "executionInfo": { + "elapsed": 882, + "status": "ok", + "timestamp": 1600455495680, + "user": { + "displayName": "Adem Tekin", + "photoUrl": "https://lh3.googleusercontent.com/a-/AOh14Gjji3ec_q6_sWOPCSacyEQOavzHeGZCtJpnBwD9=s64", + "userId": "01835850446278926637" + }, + "user_tz": -180 + }, + "id": "obl0Qm53Czfx", + "outputId": "f55ae184-bb4e-4869-8cf7-fe9c9ddf289b" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "intercept: 0.5825576602634852\n", + "slope: [43.08913515]\n" + ] + } + ], + "source": [ + "print('intercept:', model.intercept_)\n", + "print('slope:', model.coef_)\n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "colab_type": "text", + "id": "L3CUuxm0nBb3" + }, + "source": [ + "### Predict" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 52 + }, + "colab_type": "code", + "executionInfo": { + "elapsed": 917, + "status": "ok", + "timestamp": 1600455553379, + "user": { + "displayName": "Adem Tekin", + "photoUrl": "https://lh3.googleusercontent.com/a-/AOh14Gjji3ec_q6_sWOPCSacyEQOavzHeGZCtJpnBwD9=s64", + "userId": "01835850446278926637" + }, + "user_tz": -180 + }, + "id": "b8Jb11mTCzMV", + "outputId": "e54c5f07-4136-49cb-e731-c8066fe192ea" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "predicted response:\n", + "[ 4.07106126e+01 4.33334055e+00 -4.49932915e+01 1.41232034e+01\n", + " -2.00646458e+01 2.84908966e+01 -1.93857099e+01 2.39610007e+01\n", + " 2.69391599e+01 4.38239223e+01 3.59976258e+01 6.68552231e+01\n", + " 3.24024439e+01 -8.88291400e+00 -3.42547325e+01 4.53645016e+00\n", + " -8.38579332e+01 2.26988075e+01 4.50074354e+01 -1.12299993e+02\n", + " 2.19855409e+01 4.76554530e+00 -1.94853346e+01 4.00264432e+01\n", + " 6.80016996e+01 6.37360956e+01 -2.52984440e+01 -9.61155381e-01\n", + " -2.53444599e+01 -5.09609512e+01 1.59702295e+01 1.67710603e+01\n", + " 1.18312036e+01 -2.22443514e+01 -3.85434145e+01 9.06513806e+00\n", + " -1.23014105e+01 1.61651412e+01 3.60253065e+01 -1.19862737e+01\n", + " 1.61547817e+01 -2.85854259e+01 6.62085970e+01 -2.17492578e+01\n", + " -9.50690875e+00 -1.63130435e+01 -1.23917402e+01 -2.72150946e+01\n", + " 1.47481587e+01 9.58230933e+00 -1.35361209e+01 8.02892085e-01\n", + " -9.50620132e+00 6.42637339e+01 -1.60103048e+01 1.53887726e+01\n", + " 1.48564124e+01 -7.41732708e+00 -9.52559904e+00 -8.50600679e+01\n", + " 1.45470556e+01 -9.14594787e+00 -4.70884596e+01 -2.96683030e+01\n", + " -6.24790357e+01 4.23206326e+01 -7.37426600e+01 -8.18590334e+01\n", + " -2.36459257e+01 3.36506564e+01 3.55935926e+01 -6.02723874e+01\n", + " -6.31256762e+01 -5.20225394e+01 -3.55785996e+01 6.86294721e+01\n", + " 4.26179535e+01 1.10085027e+01 1.33421243e+01 -2.28744231e+01\n", + " -7.53853179e+01 5.36211612e+00 7.96666869e+00 -5.66478305e+01\n", + " 4.61330401e+01 -4.40062681e+00 -1.96466876e+01 9.73919333e-04\n", + " -4.30594594e+01 -5.37513150e+00 -4.90127602e+01 5.90217676e+01\n", + " 3.49228960e+00 -2.10377194e+01 -1.92659686e+01 8.03956227e+01\n", + " -6.08086095e+01 -3.04349067e+01 -2.52029620e+00 -1.27411362e+01]\n" + ] + } + ], + "source": [ + "X_test, y_test = make_regression(n_samples=100, n_features=1, noise=20 ,random_state=42)\n", + "y_pred = model.predict(X_test)\n", + "print('predicted response:', y_pred, sep='\\n')" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 11, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plt.scatter(X, y, color=\"red\")\n", + "plt.scatter(X_test, y_pred)" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "0.9872919587211264" + ] + }, + "execution_count": 12, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "model.score(X, y)" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Coefficient of determination (R2) of test: 0.8460442632197438\n" + ] + } + ], + "source": [ + "r_t = model.score(X_test, y_test)\n", + "print('Coefficient of determination (R2) of test:', r_t)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "colab_type": "text", + "id": "icAi86X1nJLc" + }, + "source": [ + "## Multiple Linear Regression With scikit-learn" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "colab_type": "text", + "id": "H0xTkmm_nVJ9" + }, + "source": [ + "### Provide Data" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 176 + }, + "colab_type": "code", + "executionInfo": { + "elapsed": 780, + "status": "ok", + "timestamp": 1600456172877, + "user": { + "displayName": "Adem Tekin", + "photoUrl": "https://lh3.googleusercontent.com/a-/AOh14Gjji3ec_q6_sWOPCSacyEQOavzHeGZCtJpnBwD9=s64", + "userId": "01835850446278926637" + }, + "user_tz": -180 + }, + "id": "Diw806hRl1A_", + "outputId": "c65a73ab-25ae-49d7-d252-8eca3500a059" + }, + "outputs": [], + "source": [ + "from sklearn.datasets import make_regression\n", + "X_m, y_m = make_regression(n_samples=100, n_features=2, noise=20,random_state=42)" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[ 0.05820872, -1.1429703 ],\n", + " [ 0.58685709, 2.19045563],\n", + " [ 0.47323762, -0.07282891],\n", + " [ 0.73846658, 0.17136828]])" + ] + }, + "execution_count": 18, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "X_m[1:5]" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "colab_type": "text", + "id": "otpUMvJZn1kM" + }, + "source": [ + "### Create a model & fit" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": { + "colab": {}, + "colab_type": "code", + "id": "3CHiKIZZl1K6" + }, + "outputs": [], + "source": [ + "model = LinearRegression().fit(X_m, y_m)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "colab_type": "text", + "id": "kLOWx40on-L0" + }, + "source": [ + "### Get Results" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 70 + }, + "colab_type": "code", + "executionInfo": { + "elapsed": 910, + "status": "ok", + "timestamp": 1600456293410, + "user": { + "displayName": "Adem Tekin", + "photoUrl": "https://lh3.googleusercontent.com/a-/AOh14Gjji3ec_q6_sWOPCSacyEQOavzHeGZCtJpnBwD9=s64", + "userId": "01835850446278926637" + }, + "user_tz": -180 + }, + "id": "iBt3pM-hl1S4", + "outputId": "77ac4fff-59d2-4598-c567-1bcbbf13861f" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "coefficient of determination: 0.959604849170989\n", + "intercept: 0.43271616892190323\n", + "slope: [84.26785337 74.15664645]\n" + ] + } + ], + "source": [ + "r_sq = model.score(X_m, y_m)\n", + "print('coefficient of determination:', r_sq)\n", + "print('intercept:', model.intercept_)\n", + "print('slope:', model.coef_)\n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "colab_type": "text", + "id": "TY6mePg5oSBE" + }, + "source": [ + "### Predict" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 70 + }, + "colab_type": "code", + "executionInfo": { + "elapsed": 1542, + "status": "ok", + "timestamp": 1600456327996, + "user": { + "displayName": "Adem Tekin", + "photoUrl": "https://lh3.googleusercontent.com/a-/AOh14Gjji3ec_q6_sWOPCSacyEQOavzHeGZCtJpnBwD9=s64", + "userId": "01835850446278926637" + }, + "user_tz": -180 + }, + "id": "6ViFtCWfl1a5", + "outputId": "27a58f97-7a0f-4896-a3e5-a275700519ef", + "scrolled": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "predicted response:\n", + "[ -53.2618421 -81.47203332 182.21191983 -185.91510539 -48.19449499\n", + " -30.58967254 -142.85219232 -89.69922222 -68.68904094 -149.21585472\n", + " -41.44798528 90.09462956 -73.17883242 -174.86416876 -114.62008988\n", + " -36.66153161 11.33844031 111.89967811 25.61613614 176.80558272]\n" + ] + } + ], + "source": [ + "Xm_test, ym_test = make_regression(n_samples=20, n_features=2, noise=20, random_state=42)\n", + "\n", + "ym_pred = model.predict(Xm_test)\n", + "print('predicted response:', ym_pred, sep='\\n')" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Coefficient of determination (R2) of test: 0.9587826719061527\n" + ] + } + ], + "source": [ + "print('Coefficient of determination (R2) of test:', model.score(Xm_test,ym_test))" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "0.9587826719061527" + ] + }, + "execution_count": 25, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from sklearn.metrics import r2_score\n", + "r2_score(ym_test, ym_pred)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "colab_type": "text", + "id": "0t2bMe0DruXG" + }, + "source": [ + "## Cost Function" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "colab_type": "text", + "id": "h0d9Gg4Sr_JD" + }, + "source": [ + "It is a function that measures the performance of a Machine Learning model for given data. Cost Function quantifies the error between predicted values and expected values and presents it in the form of a single real number." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "colab_type": "text", + "id": "3KrPoOTJjDpS" + }, + "source": [ + "$$MSE = \\frac{1}{m}\\sum_{n=1}^{m} (y_p-y)^{2}$$" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "colab_type": "text", + "id": "b-CqFQ0cmijD" + }, + "source": [ + "#### Mean Square Error (MSE)" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [], + "source": [ + "from sklearn.metrics import mean_squared_error" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "19.513562605309748" + ] + }, + "execution_count": 15, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "mean_squared_error(y, y_pred)" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "19.513562605309748" + ] + }, + "execution_count": 16, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "np.mean((y - y_pred)**2)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Mean Square Error (MAE)" + ] + }, + { + "cell_type": "code", + "execution_count": 104, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "3.5522465657069584" + ] + }, + "execution_count": 104, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from sklearn.metrics import mean_absolute_error\n", + "mean_absolute_error(y,y_pred)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Adjusted ($R^2$)\n", + "\n", + "Adjusted R2 also indicates how well terms fit a curve or line, but adjusts for the number of terms in a model. If you add more and more useless variables to a model, adjusted r-squared will decrease. If you add more useful variables, adjusted r-squared will increase.\n", + "Adjusted $R^2$ will always be less than or equal to $R^2$." + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "metadata": {}, + "outputs": [], + "source": [ + "def adj_r2 (X,y,model):\n", + " r_squared = model.score(X,y)\n", + " return(1 - (1-r_squared)*(len(y)-1)/(len(y)-X.shape[1]-1))" + ] + }, + { + "cell_type": "code", + "execution_count": 33, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "0.9539335744833471" + ] + }, + "execution_count": 33, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "adj_r2(Xm_test, ym_test, model)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Real Life Example" + ] + }, + { + "cell_type": "code", + "execution_count": 37, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
CRIMZNINDUSCHASNOXRMAGEDISRADTAXPTRATIOBLSTAT
00.0063218.02.310.00.5386.57565.24.09001.0296.015.3396.904.98
10.027310.07.070.00.4696.42178.94.96712.0242.017.8396.909.14
20.027290.07.070.00.4697.18561.14.96712.0242.017.8392.834.03
30.032370.02.180.00.4586.99845.86.06223.0222.018.7394.632.94
40.069050.02.180.00.4587.14754.26.06223.0222.018.7396.905.33
\n", + "
" + ], + "text/plain": [ + " CRIM ZN INDUS CHAS NOX RM AGE DIS RAD TAX \\\n", + "0 0.00632 18.0 2.31 0.0 0.538 6.575 65.2 4.0900 1.0 296.0 \n", + "1 0.02731 0.0 7.07 0.0 0.469 6.421 78.9 4.9671 2.0 242.0 \n", + "2 0.02729 0.0 7.07 0.0 0.469 7.185 61.1 4.9671 2.0 242.0 \n", + "3 0.03237 0.0 2.18 0.0 0.458 6.998 45.8 6.0622 3.0 222.0 \n", + "4 0.06905 0.0 2.18 0.0 0.458 7.147 54.2 6.0622 3.0 222.0 \n", + "\n", + " PTRATIO B LSTAT \n", + "0 15.3 396.90 4.98 \n", + "1 17.8 396.90 9.14 \n", + "2 17.8 392.83 4.03 \n", + "3 18.7 394.63 2.94 \n", + "4 18.7 396.90 5.33 " + ] + }, + "execution_count": 37, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from sklearn.datasets import load_boston\n", + "import pandas as pd\n", + "\n", + "Xb,yb =load_boston(return_X_y=True)\n", + "\n", + "df_boston = pd.DataFrame(Xb,columns = load_boston().feature_names)\n", + "df_boston.head()" + ] + }, + { + "cell_type": "code", + "execution_count": 38, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "RangeIndex: 506 entries, 0 to 505\n", + "Data columns (total 13 columns):\n", + " # Column Non-Null Count Dtype \n", + "--- ------ -------------- ----- \n", + " 0 CRIM 506 non-null float64\n", + " 1 ZN 506 non-null float64\n", + " 2 INDUS 506 non-null float64\n", + " 3 CHAS 506 non-null float64\n", + " 4 NOX 506 non-null float64\n", + " 5 RM 506 non-null float64\n", + " 6 AGE 506 non-null float64\n", + " 7 DIS 506 non-null float64\n", + " 8 RAD 506 non-null float64\n", + " 9 TAX 506 non-null float64\n", + " 10 PTRATIO 506 non-null float64\n", + " 11 B 506 non-null float64\n", + " 12 LSTAT 506 non-null float64\n", + "dtypes: float64(13)\n", + "memory usage: 51.5 KB\n" + ] + } + ], + "source": [ + "df_boston.info()" + ] + }, + { + "cell_type": "code", + "execution_count": 39, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
CRIMZNINDUSCHASNOXRMAGEDISRADTAXPTRATIOBLSTAT
count506.000000506.000000506.000000506.000000506.000000506.000000506.000000506.000000506.000000506.000000506.000000506.000000506.000000
mean3.61352411.36363611.1367790.0691700.5546956.28463468.5749013.7950439.549407408.23715418.455534356.67403212.653063
std8.60154523.3224536.8603530.2539940.1158780.70261728.1488612.1057108.707259168.5371162.16494691.2948647.141062
min0.0063200.0000000.4600000.0000000.3850003.5610002.9000001.1296001.000000187.00000012.6000000.3200001.730000
25%0.0820450.0000005.1900000.0000000.4490005.88550045.0250002.1001754.000000279.00000017.400000375.3775006.950000
50%0.2565100.0000009.6900000.0000000.5380006.20850077.5000003.2074505.000000330.00000019.050000391.44000011.360000
75%3.67708312.50000018.1000000.0000000.6240006.62350094.0750005.18842524.000000666.00000020.200000396.22500016.955000
max88.976200100.00000027.7400001.0000000.8710008.780000100.00000012.12650024.000000711.00000022.000000396.90000037.970000
\n", + "
" + ], + "text/plain": [ + " CRIM ZN INDUS CHAS NOX RM \\\n", + "count 506.000000 506.000000 506.000000 506.000000 506.000000 506.000000 \n", + "mean 3.613524 11.363636 11.136779 0.069170 0.554695 6.284634 \n", + "std 8.601545 23.322453 6.860353 0.253994 0.115878 0.702617 \n", + "min 0.006320 0.000000 0.460000 0.000000 0.385000 3.561000 \n", + "25% 0.082045 0.000000 5.190000 0.000000 0.449000 5.885500 \n", + "50% 0.256510 0.000000 9.690000 0.000000 0.538000 6.208500 \n", + "75% 3.677083 12.500000 18.100000 0.000000 0.624000 6.623500 \n", + "max 88.976200 100.000000 27.740000 1.000000 0.871000 8.780000 \n", + "\n", + " AGE DIS RAD TAX PTRATIO B \\\n", + "count 506.000000 506.000000 506.000000 506.000000 506.000000 506.000000 \n", + "mean 68.574901 3.795043 9.549407 408.237154 18.455534 356.674032 \n", + "std 28.148861 2.105710 8.707259 168.537116 2.164946 91.294864 \n", + "min 2.900000 1.129600 1.000000 187.000000 12.600000 0.320000 \n", + "25% 45.025000 2.100175 4.000000 279.000000 17.400000 375.377500 \n", + "50% 77.500000 3.207450 5.000000 330.000000 19.050000 391.440000 \n", + "75% 94.075000 5.188425 24.000000 666.000000 20.200000 396.225000 \n", + "max 100.000000 12.126500 24.000000 711.000000 22.000000 396.900000 \n", + "\n", + " LSTAT \n", + "count 506.000000 \n", + "mean 12.653063 \n", + "std 7.141062 \n", + "min 1.730000 \n", + "25% 6.950000 \n", + "50% 11.360000 \n", + "75% 16.955000 \n", + "max 37.970000 " + ] + }, + "execution_count": 39, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "df_boston.describe()" + ] + }, + { + "cell_type": "code", + "execution_count": 47, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "CRIM 0\n", + "ZN 0\n", + "INDUS 0\n", + "CHAS 0\n", + "NOX 0\n", + "RM 0\n", + "AGE 0\n", + "DIS 0\n", + "RAD 0\n", + "TAX 0\n", + "PTRATIO 0\n", + "B 0\n", + "LSTAT 0\n", + "dtype: int64" + ] + }, + "execution_count": 47, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "df_boston.isna().sum()" + ] + }, + { + "cell_type": "code", + "execution_count": 48, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# Correlation of the features\n", + "import seaborn as sns\n", + "corr = df_boston.corr()\n", + "\n", + "plt.figure(figsize=(14, 14))\n", + "ax = sns.heatmap(\n", + " corr, \n", + " vmin=-1, vmax=1, center=0,\n", + " cmap=sns.diverging_palette(20, 220, n=200),\n", + " square=True, annot = True\n", + ")\n", + "ax.set_xticklabels(\n", + " ax.get_xticklabels(),\n", + " rotation=45,\n", + " horizontalalignment='right'\n", + ")\n", + "ax.set_ylim(len(corr)+0.5, -0.5);" + ] + }, + { + "cell_type": "code", + "execution_count": 50, + "metadata": {}, + "outputs": [], + "source": [ + "from sklearn.model_selection import train_test_split\n", + "X_train, X_test, y_train, y_test = train_test_split(Xb,yb, test_size=0.3, random_state=42)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "`train_test_split` splits arrays or matrices into random train and test subsets. That means that everytime you run it without specifying `random_state`, you will get a different result. Thus, your project will not be reproducible." + ] + }, + { + "cell_type": "code", + "execution_count": 55, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Score of the train set 0.7434997532004697\n", + "Score of the test set 0.711226005748496\n" + ] + } + ], + "source": [ + "modelb = LinearRegression(normalize=False)\n", + "modelb.fit(X_train,y_train)\n", + "\n", + "print(\"Score of the train set\",modelb.score(X_train,y_train))\n", + "print(\"Score of the test set\",modelb.score(X_test,y_test))" + ] + }, + { + "cell_type": "code", + "execution_count": 56, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Adj. R2 of the train set 0.7336923908228405\n", + "Adj. R2 of the test set 0.6840226584639341\n" + ] + } + ], + "source": [ + "print(\"Adj. R2 of the train set\",adj_r2(X_train,y_train,modelb))\n", + "print(\"Adj. R2 of the test set\",adj_r2(X_test,y_test,modelb))" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Feature CRIM Score: -0.13347010285294553\n", + "Feature ZN Score: 0.03580891359323298\n", + "Feature INDUS Score: 0.04952264522005613\n", + "Feature CHAS Score: 3.119835116285376\n", + "Feature NOX Score: -15.417060895306665\n", + "Feature RM Score: 4.057199231645383\n", + "Feature AGE Score: -0.010820835184928124\n", + "Feature DIS Score: -1.3859982431608822\n", + "Feature RAD Score: 0.24272733982225028\n", + "Feature TAX Score: -0.0087022343656624\n", + "Feature PTRATIO Score: -0.9106852081102877\n", + "Feature B Score: 0.011794115892572747\n", + "Feature LSTAT Score: -0.5471133128239566\n" + ] + } + ], + "source": [ + "importance = modelb.coef_\n", + "for i in range(len(importance)):\n", + " print(\"Feature\", df_boston.columns[i], \"Score:\", importance[i])" + ] + }, + { + "cell_type": "code", + "execution_count": 57, + "metadata": {}, + "outputs": [], + "source": [ + "# Dropping colerated features\n", + "new_df = df_boston.drop([\"AGE\",\"INDUS\"],axis=1)" + ] + }, + { + "cell_type": "code", + "execution_count": 58, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Score of the train set 0.7428288884259309\n", + "Score of the test set 0.7149039348907364\n" + ] + } + ], + "source": [ + "X_train, X_test, y_train, y_test = train_test_split(new_df,yb, test_size=0.3, random_state=42)\n", + "modelb = LinearRegression(normalize=True)\n", + "modelb.fit(X_train,y_train)\n", + "print(\"Score of the train set\",modelb.score(X_train,y_train))\n", + "print(\"Score of the test set\",modelb.score(X_test,y_test))" + ] + }, + { + "cell_type": "code", + "execution_count": 59, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Score of the train set 0.7345573029659462\n", + "Score of the test set 0.6925035297750086\n" + ] + } + ], + "source": [ + "print(\"Score of the train set\",adj_r2(X_train,y_train,modelb))\n", + "print(\"Score of the test set\",adj_r2(X_test,y_test,modelb))" + ] + }, + { + "cell_type": "code", + "execution_count": 66, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[0.41978194, 0.28482986, 1.2879095 , ..., 1.45900038, 0.44105193,\n", + " 1.0755623 ],\n", + " [0.41733926, 0.48772236, 0.59338101, ..., 0.30309415, 0.44105193,\n", + " 0.49243937],\n", + " [0.41734159, 0.48772236, 0.59338101, ..., 0.30309415, 0.39642699,\n", + " 1.2087274 ],\n", + " ...,\n", + " [0.41344658, 0.48772236, 0.11573841, ..., 1.17646583, 0.44105193,\n", + " 0.98304761],\n", + " [0.40776407, 0.48772236, 0.11573841, ..., 1.17646583, 0.4032249 ,\n", + " 0.86530163],\n", + " [0.41500016, 0.48772236, 0.11573841, ..., 1.17646583, 0.44105193,\n", + " 0.66905833]])" + ] + }, + "execution_count": 66, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Scaling\n", + "from scipy import stats\n", + "import numpy as np\n", + "z = np.abs(stats.zscore(df_boston))\n", + "z" + ] + }, + { + "cell_type": "code", + "execution_count": 63, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "100" + ] + }, + "execution_count": 63, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "len(np.where(z > 3)[0])" + ] + }, + { + "cell_type": "code", + "execution_count": 67, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
indexCRIMZNINDUSCHASNOXRMAGEDISRADTAXPTRATIOBLSTAT
000.0063218.02.310.00.5386.57565.24.09001.0296.015.3396.904.98
110.027310.07.070.00.4696.42178.94.96712.0242.017.8396.909.14
220.027290.07.070.00.4697.18561.14.96712.0242.017.8392.834.03
330.032370.02.180.00.4586.99845.86.06223.0222.018.7394.632.94
440.069050.02.180.00.4587.14754.26.06223.0222.018.7396.905.33
.............................................
4105010.062630.011.930.00.5736.59369.12.47861.0273.021.0391.999.67
4115020.045270.011.930.00.5736.12076.72.28751.0273.021.0396.909.08
4125030.060760.011.930.00.5736.97691.02.16751.0273.021.0396.905.64
4135040.109590.011.930.00.5736.79489.32.38891.0273.021.0393.456.48
4145050.047410.011.930.00.5736.03080.82.50501.0273.021.0396.907.88
\n", + "

415 rows × 14 columns

\n", + "
" + ], + "text/plain": [ + " index CRIM ZN INDUS CHAS NOX RM AGE DIS RAD \\\n", + "0 0 0.00632 18.0 2.31 0.0 0.538 6.575 65.2 4.0900 1.0 \n", + "1 1 0.02731 0.0 7.07 0.0 0.469 6.421 78.9 4.9671 2.0 \n", + "2 2 0.02729 0.0 7.07 0.0 0.469 7.185 61.1 4.9671 2.0 \n", + "3 3 0.03237 0.0 2.18 0.0 0.458 6.998 45.8 6.0622 3.0 \n", + "4 4 0.06905 0.0 2.18 0.0 0.458 7.147 54.2 6.0622 3.0 \n", + ".. ... ... ... ... ... ... ... ... ... ... \n", + "410 501 0.06263 0.0 11.93 0.0 0.573 6.593 69.1 2.4786 1.0 \n", + "411 502 0.04527 0.0 11.93 0.0 0.573 6.120 76.7 2.2875 1.0 \n", + "412 503 0.06076 0.0 11.93 0.0 0.573 6.976 91.0 2.1675 1.0 \n", + "413 504 0.10959 0.0 11.93 0.0 0.573 6.794 89.3 2.3889 1.0 \n", + "414 505 0.04741 0.0 11.93 0.0 0.573 6.030 80.8 2.5050 1.0 \n", + "\n", + " TAX PTRATIO B LSTAT \n", + "0 296.0 15.3 396.90 4.98 \n", + "1 242.0 17.8 396.90 9.14 \n", + "2 242.0 17.8 392.83 4.03 \n", + "3 222.0 18.7 394.63 2.94 \n", + "4 222.0 18.7 396.90 5.33 \n", + ".. ... ... ... ... \n", + "410 273.0 21.0 391.99 9.67 \n", + "411 273.0 21.0 396.90 9.08 \n", + "412 273.0 21.0 396.90 5.64 \n", + "413 273.0 21.0 393.45 6.48 \n", + "414 273.0 21.0 396.90 7.88 \n", + "\n", + "[415 rows x 14 columns]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/plain": [ + "415" + ] + }, + "execution_count": 67, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "outliers = list(set(np.where(z > 3)[0]))\n", + "new_df = df_boston.drop(outliers,axis = 0).reset_index(drop = False)\n", + "display(new_df)\n", + "\n", + "y_new = yb[list(new_df[\"index\"])]\n", + "len(y_new)" + ] + }, + { + "cell_type": "code", + "execution_count": 68, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[-0.50009668, 0.42727822, -1.25466328, ..., -1.48379449,\n", + " 0.43991388, -1.1282211 ],\n", + " [-0.49580542, -0.48858069, -0.55367539, ..., -0.312853 ,\n", + " 0.43991388, -0.48493501],\n", + " [-0.49580951, -0.48858069, -0.55367539, ..., -0.312853 ,\n", + " 0.36091635, -1.27512537],\n", + " ...,\n", + " [-0.4889668 , -0.48858069, 0.16203913, ..., 1.18595212,\n", + " 0.43991388, -1.02616129],\n", + " [-0.47898384, -0.48858069, 0.16203913, ..., 1.18595212,\n", + " 0.37295037, -0.89626698],\n", + " [-0.49169611, -0.48858069, 0.16203913, ..., 1.18595212,\n", + " 0.43991388, -0.67977647]])" + ] + }, + "execution_count": 68, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "X_new = new_df.drop('index', axis = 1)\n", + "\n", + "from sklearn.preprocessing import StandardScaler, MinMaxScaler\n", + "X_scaled = StandardScaler().fit_transform(X_new)\n", + "X_scaled" + ] + }, + { + "cell_type": "code", + "execution_count": 69, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Score of the train set 0.7598701100873175\n", + "Score of the test set 0.6739782514175501\n" + ] + } + ], + "source": [ + "# Outliers removed & scaling\n", + "X_train, X_test, y_train, y_test = train_test_split(X_scaled,y_new, test_size=0.3, random_state=42)\n", + "modelb = LinearRegression(normalize=False)\n", + "modelb.fit(X_train,y_train)\n", + "print(\"Score of the train set\",modelb.score(X_train,y_train))\n", + "print(\"Score of the test set\",modelb.score(X_test,y_test))" + ] + }, + { + "cell_type": "code", + "execution_count": 70, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Score of the train set 0.7434997532004697\n", + "Score of the test set 0.711226005748496\n" + ] + } + ], + "source": [ + "# With outliers & not scaled\n", + "X_train, X_test, y_train, y_test = train_test_split(Xb,yb, test_size=0.3, random_state=42)\n", + "modelb = LinearRegression(normalize=False)\n", + "modelb.fit(X_train,y_train)\n", + "print(\"Score of the train set\",modelb.score(X_train,y_train))\n", + "print(\"Score of the test set\",modelb.score(X_test,y_test))" + ] + }, + { + "cell_type": "code", + "execution_count": 71, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Score of the train set 0.7434997532004697\n", + "Score of the test set 0.7112260057484925\n" + ] + } + ], + "source": [ + "# With outlier but scaling\n", + "X_alls = StandardScaler().fit_transform(Xb)\n", + "X_train, X_test, y_train, y_test = train_test_split(X_alls,yb, test_size=0.3, random_state=42)\n", + "\n", + "modelb = LinearRegression(normalize=False)\n", + "modelb.fit(X_train,y_train)\n", + "print(\"Score of the train set\",modelb.score(X_train,y_train))\n", + "print(\"Score of the test set\",modelb.score(X_test,y_test))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Resorces\n", + "https://towardsdatascience.com/statistics-supporting-linear-models-bfc24fb9781f \n", + " " + ] + } + ], + "metadata": { + "colab": { + "collapsed_sections": [], + "name": "ML Zemin.ipynb", + "provenance": [] + }, + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.7.3" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/Linear Regression/linear_regression.ipynb b/Linear Regression/linear_regression.ipynb index 31ec2ef..ab92f1e 100644 --- a/Linear Regression/linear_regression.ipynb +++ b/Linear Regression/linear_regression.ipynb @@ -2123,7 +2123,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.7.3" + "version": "3.7.9" } }, "nbformat": 4, diff --git a/Logistic Regression/.ipynb_checkpoints/logistic_regression-checkpoint.ipynb b/Logistic Regression/.ipynb_checkpoints/logistic_regression-checkpoint.ipynb new file mode 100644 index 0000000..33fd463 --- /dev/null +++ b/Logistic Regression/.ipynb_checkpoints/logistic_regression-checkpoint.ipynb @@ -0,0 +1,2111 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + " \"Open\n", + "" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "colab_type": "text", + "id": "O1lN5imPlfWb" + }, + "source": [ + " All rights reserved © Global AI Hub 2020 \n", + "![](img/logo.png)\n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "colab_type": "text", + "id": "4CTfJC29leb8" + }, + "source": [ + "# Logistic Regression " + ] + }, + { + "cell_type": "markdown", + "metadata": { + "colab_type": "text", + "id": "_iq3Lo2Eleb9" + }, + "source": [ + "Logistic regression is a fundamental classification technique. It belongs to the group of linear classifiers and is somewhat similar to polynomial and linear regression. Logistic regression is fast and relatively uncomplicated, and it’s convenient for you to interpret the results. Although it’s essentially a method for binary classification, it can also be applied to multiclass problems." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "colab_type": "text", + "id": "GA8bmkyAleb-" + }, + "source": [ + "You’ll need an understanding of the sigmoid function and the natural logarithm function to understand what logistic regression is and how it works.\n", + "\n", + "This image shows the sigmoid function (or S-shaped curve) of some variable 𝑥:" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "colab_type": "text", + "id": "s97qP9XJleb-" + }, + "source": [ + "" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "colab_type": "text", + "id": "8euP2T8zleb_" + }, + "source": [ + "The sigmoid function has values very close to either 0 or 1 across most of its domain. This fact makes it suitable for application in classification methods." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "colab_type": "text", + "id": "mWzlA4vqleb_" + }, + "source": [ + "## Single-Variate Logistic Regression" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "colab_type": "text", + "id": "pzzWSR2glecA" + }, + "source": [ + "Single-variate logistic regression is the most straightforward case of logistic regression. There is only one independent variable (or feature), which is 𝐱 = 𝑥. This figure illustrates single-variate logistic regression:" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "colab_type": "text", + "id": "CfiHv1p1lecB" + }, + "source": [ + "" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "colab_type": "text", + "id": "WdQx45HKlecB" + }, + "source": [ + "Here, you have a given set of input-output (or 𝑥-𝑦) pairs, represented by green circles. These are your observations. Remember that 𝑦 can only be 0 or 1. For example, the leftmost green circle has the input 𝑥 = 0 and the actual output 𝑦 = 0. The rightmost observation has 𝑥 = 9 and 𝑦 = 1.\n", + "\n", + "Logistic regression finds the weights 𝑏₀ and 𝑏₁ that correspond to the maximum log-likelihood function (LLF). These weights define the logit 𝑓(𝑥) = 𝑏₀ + 𝑏₁𝑥, which is the dashed black line. They also define the predicted probability $p(x) = 1 / (1 + exp(−𝑓(𝑥)))$, shown here as the full black line. In this case, the threshold 𝑝(𝑥) = 0.5 and 𝑓(𝑥) = 0 corresponds to the value of 𝑥 slightly higher than 3. This value is the limit between the inputs with the predicted outputs of 0 and 1." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "colab_type": "text", + "id": "GXp6HofvlecF" + }, + "source": [ + "## Logistic Regression in Python" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": { + "colab": {}, + "colab_type": "code", + "id": "ooCLpj5WlecF" + }, + "outputs": [], + "source": [ + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "from sklearn.linear_model import LogisticRegression\n", + "from sklearn.metrics import classification_report, confusion_matrix" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": { + "colab": {}, + "colab_type": "code", + "id": "ts_LzMz3lecJ" + }, + "outputs": [], + "source": [ + "x = np.arange(10).reshape(-1, 1)\n", + "y = np.array([0, 0, 0, 0, 1, 1, 1, 1, 1, 1])" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[0],\n", + " [1],\n", + " [2],\n", + " [3],\n", + " [4],\n", + " [5],\n", + " [6],\n", + " [7],\n", + " [8],\n", + " [9]])" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "x" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": { + "colab": {}, + "colab_type": "code", + "id": "ISWMaQmKlecL" + }, + "outputs": [], + "source": [ + "model = LogisticRegression(random_state = 42)" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": { + "colab": {}, + "colab_type": "code", + "id": "kEvfhhlvlecO", + "outputId": "afc1edc9-773d-48ed-b22c-cb8b6d757828" + }, + "outputs": [ + { + "data": { + "text/plain": [ + "LogisticRegression(C=1.0, class_weight=None, dual=False, fit_intercept=True,\n", + " intercept_scaling=1, l1_ratio=None, max_iter=100,\n", + " multi_class='auto', n_jobs=None, penalty='l2',\n", + " random_state=42, solver='lbfgs', tol=0.0001, verbose=0,\n", + " warm_start=False)" + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "model.fit(x, y)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "colab_type": "text", + "id": "P1KY8ygglecS" + }, + "source": [ + "LogisticRegression(C=1.0, class_weight=None, dual=False, fit_intercept=True,\n", + " intercept_scaling=1, l1_ratio=None, max_iter=100,\n", + " multi_class='warn', n_jobs=None, penalty='l2',\n", + " random_state=0, solver='liblinear', tol=0.0001, verbose=0,\n", + " warm_start=False)" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": { + "colab": {}, + "colab_type": "code", + "id": "TWyHYujKleca", + "outputId": "6efac8d8-9adf-4ac5-e982-fae7942ad8b4" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Classes: [0 1]\n", + "Intercept: [-4.12617727]\n", + "Coef: [[1.18109091]]\n" + ] + } + ], + "source": [ + "print(\"Classes: \", model.classes_)\n", + "print(\"Intercept: \",model.intercept_)\n", + "print(\"Coef: \",model.coef_)" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Probability: [[0.98411203 0.01588797]\n", + " [0.95003074 0.04996926]\n", + " [0.85370936 0.14629064]\n", + " [0.64173546 0.35826454]\n", + " [0.35475873 0.64524127]\n", + " [0.1443924 0.8556076 ]\n", + " [0.04924876 0.95075124]\n", + " [0.01565079 0.98434921]\n", + " [0.00485659 0.99514341]\n", + " [0.00149573 0.99850427]]\n" + ] + } + ], + "source": [ + "print(\"Probability: \",model.predict_proba(x))" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": { + "colab": {}, + "colab_type": "code", + "id": "WD6Inaewlecl", + "outputId": "ecd200d5-70e5-498d-fa31-06c8d9b0cc26" + }, + "outputs": [ + { + "data": { + "text/plain": [ + "array([0, 0, 0, 0, 1, 1, 1, 1, 1, 1])" + ] + }, + "execution_count": 12, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "model.predict(x)" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": { + "colab": {}, + "colab_type": "code", + "id": "inYjtdS9lecq", + "outputId": "c8a25a25-2ab6-445f-af43-a6c298943ac8" + }, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[4, 0],\n", + " [0, 6]], dtype=int64)" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "confusion_matrix(y, model.predict(x))" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": { + "colab": {}, + "colab_type": "code", + "id": "U3CLyPvTlect", + "outputId": "b41cb437-bf7b-4296-a2fa-6777aaa496f3" + }, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "import seaborn as sns\n", + "\n", + "cm = confusion_matrix(y, model.predict(x))\n", + "sns.heatmap(cm, annot=True)" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": { + "colab": {}, + "colab_type": "code", + "id": "hsUoY8_flecv", + "outputId": "dcc208a4-87be-42df-80c5-93fc0dc646f5" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " precision recall f1-score support\n", + "\n", + " 0 1.00 1.00 1.00 4\n", + " 1 1.00 1.00 1.00 6\n", + "\n", + " accuracy 1.00 10\n", + " macro avg 1.00 1.00 1.00 10\n", + "weighted avg 1.00 1.00 1.00 10\n", + "\n" + ] + } + ], + "source": [ + "print(classification_report(y, model.predict(x)))" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": { + "colab": {}, + "colab_type": "code", + "id": "3wYZj-pllecy", + "outputId": "8d198813-a002-4cc4-ba2b-56f232758d81" + }, + "outputs": [ + { + "data": { + "text/plain": [ + "LogisticRegression(C=0.5, class_weight=None, dual=False, fit_intercept=True,\n", + " intercept_scaling=1, l1_ratio=None, max_iter=100,\n", + " multi_class='auto', n_jobs=None, penalty='l2',\n", + " random_state=0, solver='liblinear', tol=0.0001, verbose=0,\n", + " warm_start=False)" + ] + }, + "execution_count": 13, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "model = LogisticRegression(solver='liblinear', C=0.5, random_state=0)\n", + "model.fit(x, y)" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": { + "colab": {}, + "colab_type": "code", + "id": "2c1MUas8lec1", + "outputId": "d993f8fc-2808-47fb-bc1b-a66546e1523f" + }, + "outputs": [ + { + "data": { + "text/plain": [ + "array([-0.61167085])" + ] + }, + "execution_count": 14, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "model.intercept_" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": { + "colab": {}, + "colab_type": "code", + "id": "5MAptsgclec3", + "outputId": "501c5009-bbce-4f07-d150-ebcef755ead0" + }, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[0.41299976]])" + ] + }, + "execution_count": 15, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "model.coef_" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": { + "colab": {}, + "colab_type": "code", + "id": "Kl20AVxHlec5", + "outputId": "de7bd512-6213-4da1-ffd1-d443b89acb0c" + }, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[0.64832185, 0.35167815],\n", + " [0.54950505, 0.45049495],\n", + " [0.44662201, 0.55337799],\n", + " [0.34811656, 0.65188344],\n", + " [0.26108668, 0.73891332],\n", + " [0.18948992, 0.81051008],\n", + " [0.13396721, 0.86603279],\n", + " [0.09284959, 0.90715041],\n", + " [0.06342763, 0.93657237],\n", + " [0.04288806, 0.95711194]])" + ] + }, + "execution_count": 16, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "model.predict_proba(x)" + ] + }, + { + "cell_type": "code", + "execution_count": 51, + "metadata": { + "colab": {}, + "colab_type": "code", + "id": "30IDSy4Ilec7", + "outputId": "e6e56ded-0da2-407c-eef9-435d1fae557b" + }, + "outputs": [ + { + "data": { + "text/plain": [ + "array([0, 0, 1, 1, 1, 1, 1, 1, 1, 1])" + ] + }, + "execution_count": 51, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "model.predict(x)" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": { + "colab": {}, + "colab_type": "code", + "id": "iMBDTGVJlec9", + "outputId": "4d13e887-6896-4b03-f4f0-1713f63bb735" + }, + "outputs": [ + { + "data": { + "text/plain": [ + "0.8" + ] + }, + "execution_count": 18, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "model.score(x, y)" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": { + "colab": {}, + "colab_type": "code", + "id": "1XZwGMEZlec_", + "outputId": "b59aa2f0-687e-4e25-93e0-9eea939c51a1" + }, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[2, 2],\n", + " [0, 6]], dtype=int64)" + ] + }, + "execution_count": 19, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "confusion_matrix(y, model.predict(x))" + ] + }, + { + "cell_type": "code", + "execution_count": 56, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 56, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "sns.heatmap(confusion_matrix(y, model.predict(x)), annot=True)\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 54, + "metadata": { + "colab": {}, + "colab_type": "code", + "id": "hAo4kysIledB", + "outputId": "86fcee8c-d72c-43e3-a655-4b1e2cc4c6d4" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " precision recall f1-score support\n", + "\n", + " 0 1.00 0.50 0.67 4\n", + " 1 0.75 1.00 0.86 6\n", + "\n", + " accuracy 0.80 10\n", + " macro avg 0.88 0.75 0.76 10\n", + "weighted avg 0.85 0.80 0.78 10\n", + "\n" + ] + } + ], + "source": [ + "print(classification_report(y, model.predict(x)))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Real Life Example" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
mean radiusmean texturemean perimetermean areamean smoothnessmean compactnessmean concavitymean concave pointsmean symmetrymean fractal dimension...worst radiusworst textureworst perimeterworst areaworst smoothnessworst compactnessworst concavityworst concave pointsworst symmetryworst fractal dimension
017.9910.38122.801001.00.118400.277600.30010.147100.24190.07871...25.3817.33184.602019.00.16220.66560.71190.26540.46010.11890
120.5717.77132.901326.00.084740.078640.08690.070170.18120.05667...24.9923.41158.801956.00.12380.18660.24160.18600.27500.08902
219.6921.25130.001203.00.109600.159900.19740.127900.20690.05999...23.5725.53152.501709.00.14440.42450.45040.24300.36130.08758
311.4220.3877.58386.10.142500.283900.24140.105200.25970.09744...14.9126.5098.87567.70.20980.86630.68690.25750.66380.17300
420.2914.34135.101297.00.100300.132800.19800.104300.18090.05883...22.5416.67152.201575.00.13740.20500.40000.16250.23640.07678
\n", + "

5 rows × 30 columns

\n", + "
" + ], + "text/plain": [ + " mean radius mean texture mean perimeter mean area mean smoothness \\\n", + "0 17.99 10.38 122.80 1001.0 0.11840 \n", + "1 20.57 17.77 132.90 1326.0 0.08474 \n", + "2 19.69 21.25 130.00 1203.0 0.10960 \n", + "3 11.42 20.38 77.58 386.1 0.14250 \n", + "4 20.29 14.34 135.10 1297.0 0.10030 \n", + "\n", + " mean compactness mean concavity mean concave points mean symmetry \\\n", + "0 0.27760 0.3001 0.14710 0.2419 \n", + "1 0.07864 0.0869 0.07017 0.1812 \n", + "2 0.15990 0.1974 0.12790 0.2069 \n", + "3 0.28390 0.2414 0.10520 0.2597 \n", + "4 0.13280 0.1980 0.10430 0.1809 \n", + "\n", + " mean fractal dimension ... worst radius worst texture worst perimeter \\\n", + "0 0.07871 ... 25.38 17.33 184.60 \n", + "1 0.05667 ... 24.99 23.41 158.80 \n", + "2 0.05999 ... 23.57 25.53 152.50 \n", + "3 0.09744 ... 14.91 26.50 98.87 \n", + "4 0.05883 ... 22.54 16.67 152.20 \n", + "\n", + " worst area worst smoothness worst compactness worst concavity \\\n", + "0 2019.0 0.1622 0.6656 0.7119 \n", + "1 1956.0 0.1238 0.1866 0.2416 \n", + "2 1709.0 0.1444 0.4245 0.4504 \n", + "3 567.7 0.2098 0.8663 0.6869 \n", + "4 1575.0 0.1374 0.2050 0.4000 \n", + "\n", + " worst concave points worst symmetry worst fractal dimension \n", + "0 0.2654 0.4601 0.11890 \n", + "1 0.1860 0.2750 0.08902 \n", + "2 0.2430 0.3613 0.08758 \n", + "3 0.2575 0.6638 0.17300 \n", + "4 0.1625 0.2364 0.07678 \n", + "\n", + "[5 rows x 30 columns]" + ] + }, + "execution_count": 20, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from sklearn.datasets import load_breast_cancer\n", + "import pandas as pd\n", + "X,y = load_breast_cancer(return_X_y=True)\n", + "df = pd.DataFrame(X,columns = load_breast_cancer().feature_names)\n", + "df.head()" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "RangeIndex: 569 entries, 0 to 568\n", + "Data columns (total 30 columns):\n", + " # Column Non-Null Count Dtype \n", + "--- ------ -------------- ----- \n", + " 0 mean radius 569 non-null float64\n", + " 1 mean texture 569 non-null float64\n", + " 2 mean perimeter 569 non-null float64\n", + " 3 mean area 569 non-null float64\n", + " 4 mean smoothness 569 non-null float64\n", + " 5 mean compactness 569 non-null float64\n", + " 6 mean concavity 569 non-null float64\n", + " 7 mean concave points 569 non-null float64\n", + " 8 mean symmetry 569 non-null float64\n", + " 9 mean fractal dimension 569 non-null float64\n", + " 10 radius error 569 non-null float64\n", + " 11 texture error 569 non-null float64\n", + " 12 perimeter error 569 non-null float64\n", + " 13 area error 569 non-null float64\n", + " 14 smoothness error 569 non-null float64\n", + " 15 compactness error 569 non-null float64\n", + " 16 concavity error 569 non-null float64\n", + " 17 concave points error 569 non-null float64\n", + " 18 symmetry error 569 non-null float64\n", + " 19 fractal dimension error 569 non-null float64\n", + " 20 worst radius 569 non-null float64\n", + " 21 worst texture 569 non-null float64\n", + " 22 worst perimeter 569 non-null float64\n", + " 23 worst area 569 non-null float64\n", + " 24 worst smoothness 569 non-null float64\n", + " 25 worst compactness 569 non-null float64\n", + " 26 worst concavity 569 non-null float64\n", + " 27 worst concave points 569 non-null float64\n", + " 28 worst symmetry 569 non-null float64\n", + " 29 worst fractal dimension 569 non-null float64\n", + "dtypes: float64(30)\n", + "memory usage: 133.5 KB\n" + ] + } + ], + "source": [ + "df.info()" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
mean radiusmean texturemean perimetermean areamean smoothnessmean compactnessmean concavitymean concave pointsmean symmetrymean fractal dimension...worst radiusworst textureworst perimeterworst areaworst smoothnessworst compactnessworst concavityworst concave pointsworst symmetryworst fractal dimension
count569.000000569.000000569.000000569.000000569.000000569.000000569.000000569.000000569.000000569.000000...569.000000569.000000569.000000569.000000569.000000569.000000569.000000569.000000569.000000569.000000
mean14.12729219.28964991.969033654.8891040.0963600.1043410.0887990.0489190.1811620.062798...16.26919025.677223107.261213880.5831280.1323690.2542650.2721880.1146060.2900760.083946
std3.5240494.30103624.298981351.9141290.0140640.0528130.0797200.0388030.0274140.007060...4.8332426.14625833.602542569.3569930.0228320.1573360.2086240.0657320.0618670.018061
min6.9810009.71000043.790000143.5000000.0526300.0193800.0000000.0000000.1060000.049960...7.93000012.02000050.410000185.2000000.0711700.0272900.0000000.0000000.1565000.055040
25%11.70000016.17000075.170000420.3000000.0863700.0649200.0295600.0203100.1619000.057700...13.01000021.08000084.110000515.3000000.1166000.1472000.1145000.0649300.2504000.071460
50%13.37000018.84000086.240000551.1000000.0958700.0926300.0615400.0335000.1792000.061540...14.97000025.41000097.660000686.5000000.1313000.2119000.2267000.0999300.2822000.080040
75%15.78000021.800000104.100000782.7000000.1053000.1304000.1307000.0740000.1957000.066120...18.79000029.720000125.4000001084.0000000.1460000.3391000.3829000.1614000.3179000.092080
max28.11000039.280000188.5000002501.0000000.1634000.3454000.4268000.2012000.3040000.097440...36.04000049.540000251.2000004254.0000000.2226001.0580001.2520000.2910000.6638000.207500
\n", + "

8 rows × 30 columns

\n", + "
" + ], + "text/plain": [ + " mean radius mean texture mean perimeter mean area \\\n", + "count 569.000000 569.000000 569.000000 569.000000 \n", + "mean 14.127292 19.289649 91.969033 654.889104 \n", + "std 3.524049 4.301036 24.298981 351.914129 \n", + "min 6.981000 9.710000 43.790000 143.500000 \n", + "25% 11.700000 16.170000 75.170000 420.300000 \n", + "50% 13.370000 18.840000 86.240000 551.100000 \n", + "75% 15.780000 21.800000 104.100000 782.700000 \n", + "max 28.110000 39.280000 188.500000 2501.000000 \n", + "\n", + " mean smoothness mean compactness mean concavity mean concave points \\\n", + "count 569.000000 569.000000 569.000000 569.000000 \n", + "mean 0.096360 0.104341 0.088799 0.048919 \n", + "std 0.014064 0.052813 0.079720 0.038803 \n", + "min 0.052630 0.019380 0.000000 0.000000 \n", + "25% 0.086370 0.064920 0.029560 0.020310 \n", + "50% 0.095870 0.092630 0.061540 0.033500 \n", + "75% 0.105300 0.130400 0.130700 0.074000 \n", + "max 0.163400 0.345400 0.426800 0.201200 \n", + "\n", + " mean symmetry mean fractal dimension ... worst radius \\\n", + "count 569.000000 569.000000 ... 569.000000 \n", + "mean 0.181162 0.062798 ... 16.269190 \n", + "std 0.027414 0.007060 ... 4.833242 \n", + "min 0.106000 0.049960 ... 7.930000 \n", + "25% 0.161900 0.057700 ... 13.010000 \n", + "50% 0.179200 0.061540 ... 14.970000 \n", + "75% 0.195700 0.066120 ... 18.790000 \n", + "max 0.304000 0.097440 ... 36.040000 \n", + "\n", + " worst texture worst perimeter worst area worst smoothness \\\n", + "count 569.000000 569.000000 569.000000 569.000000 \n", + "mean 25.677223 107.261213 880.583128 0.132369 \n", + "std 6.146258 33.602542 569.356993 0.022832 \n", + "min 12.020000 50.410000 185.200000 0.071170 \n", + "25% 21.080000 84.110000 515.300000 0.116600 \n", + "50% 25.410000 97.660000 686.500000 0.131300 \n", + "75% 29.720000 125.400000 1084.000000 0.146000 \n", + "max 49.540000 251.200000 4254.000000 0.222600 \n", + "\n", + " worst compactness worst concavity worst concave points \\\n", + "count 569.000000 569.000000 569.000000 \n", + "mean 0.254265 0.272188 0.114606 \n", + "std 0.157336 0.208624 0.065732 \n", + "min 0.027290 0.000000 0.000000 \n", + "25% 0.147200 0.114500 0.064930 \n", + "50% 0.211900 0.226700 0.099930 \n", + "75% 0.339100 0.382900 0.161400 \n", + "max 1.058000 1.252000 0.291000 \n", + "\n", + " worst symmetry worst fractal dimension \n", + "count 569.000000 569.000000 \n", + "mean 0.290076 0.083946 \n", + "std 0.061867 0.018061 \n", + "min 0.156500 0.055040 \n", + "25% 0.250400 0.071460 \n", + "50% 0.282200 0.080040 \n", + "75% 0.317900 0.092080 \n", + "max 0.663800 0.207500 \n", + "\n", + "[8 rows x 30 columns]" + ] + }, + "execution_count": 22, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "df.describe()" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 25, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "import seaborn as sns\n", + "plt.figure(figsize=(16, 8))\n", + "sns.distplot(df[\"mean area\"])" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[1.09706398, 2.07333501, 1.26993369, ..., 2.29607613, 2.75062224,\n", + " 1.93701461],\n", + " [1.82982061, 0.35363241, 1.68595471, ..., 1.0870843 , 0.24388967,\n", + " 0.28118999],\n", + " [1.57988811, 0.45618695, 1.56650313, ..., 1.95500035, 1.152255 ,\n", + " 0.20139121],\n", + " ...,\n", + " [0.70228425, 2.0455738 , 0.67267578, ..., 0.41406869, 1.10454895,\n", + " 0.31840916],\n", + " [1.83834103, 2.33645719, 1.98252415, ..., 2.28998549, 1.91908301,\n", + " 2.21963528],\n", + " [1.80840125, 1.22179204, 1.81438851, ..., 1.74506282, 0.04813821,\n", + " 0.75120669]])" + ] + }, + "execution_count": 26, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from scipy import stats\n", + "import numpy as np\n", + "z = np.abs(stats.zscore(df))\n", + "z" + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "74" + ] + }, + "execution_count": 27, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "outliers = list(set(np.where(z > 3)[0]))\n", + "\n", + "len(outliers)" + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
indexmean radiusmean texturemean perimetermean areamean smoothnessmean compactnessmean concavitymean concave pointsmean symmetry...worst radiusworst textureworst perimeterworst areaworst smoothnessworst compactnessworst concavityworst concave pointsworst symmetryworst fractal dimension
0120.5717.77132.901326.00.084740.078640.086900.070170.1812...24.9923.41158.81956.00.12380.18660.24160.18600.27500.08902
1219.6921.25130.001203.00.109600.159900.197400.127900.2069...23.5725.53152.51709.00.14440.42450.45040.24300.36130.08758
2420.2914.34135.101297.00.100300.132800.198000.104300.1809...22.5416.67152.21575.00.13740.20500.40000.16250.23640.07678
3512.4515.7082.57477.10.127800.170000.157800.080890.2087...15.4723.75103.4741.60.17910.52490.53550.17410.39850.12440
4618.2519.98119.601040.00.094630.109000.112700.074000.1794...22.8827.66153.21606.00.14420.25760.37840.19320.30630.08368
..................................................................
49056014.0527.1591.38600.40.099290.112600.044620.043040.1537...15.3033.17100.2706.70.12410.22640.13260.10480.22500.08321
49156320.9225.09143.001347.00.109900.223600.317400.147400.2149...24.2929.41179.11819.00.14070.41860.65990.25420.29290.09873
49256421.5622.39142.001479.00.111000.115900.243900.138900.1726...25.4526.40166.12027.00.14100.21130.41070.22160.20600.07115
49356520.1328.25131.201261.00.097800.103400.144000.097910.1752...23.6938.25155.01731.00.11660.19220.32150.16280.25720.06637
49456616.6028.08108.30858.10.084550.102300.092510.053020.1590...18.9834.12126.71124.00.11390.30940.34030.14180.22180.07820
\n", + "

495 rows × 31 columns

\n", + "
" + ], + "text/plain": [ + " index mean radius mean texture mean perimeter mean area \\\n", + "0 1 20.57 17.77 132.90 1326.0 \n", + "1 2 19.69 21.25 130.00 1203.0 \n", + "2 4 20.29 14.34 135.10 1297.0 \n", + "3 5 12.45 15.70 82.57 477.1 \n", + "4 6 18.25 19.98 119.60 1040.0 \n", + ".. ... ... ... ... ... \n", + "490 560 14.05 27.15 91.38 600.4 \n", + "491 563 20.92 25.09 143.00 1347.0 \n", + "492 564 21.56 22.39 142.00 1479.0 \n", + "493 565 20.13 28.25 131.20 1261.0 \n", + "494 566 16.60 28.08 108.30 858.1 \n", + "\n", + " mean smoothness mean compactness mean concavity mean concave points \\\n", + "0 0.08474 0.07864 0.08690 0.07017 \n", + "1 0.10960 0.15990 0.19740 0.12790 \n", + "2 0.10030 0.13280 0.19800 0.10430 \n", + "3 0.12780 0.17000 0.15780 0.08089 \n", + "4 0.09463 0.10900 0.11270 0.07400 \n", + ".. ... ... ... ... \n", + "490 0.09929 0.11260 0.04462 0.04304 \n", + "491 0.10990 0.22360 0.31740 0.14740 \n", + "492 0.11100 0.11590 0.24390 0.13890 \n", + "493 0.09780 0.10340 0.14400 0.09791 \n", + "494 0.08455 0.10230 0.09251 0.05302 \n", + "\n", + " mean symmetry ... worst radius worst texture worst perimeter \\\n", + "0 0.1812 ... 24.99 23.41 158.8 \n", + "1 0.2069 ... 23.57 25.53 152.5 \n", + "2 0.1809 ... 22.54 16.67 152.2 \n", + "3 0.2087 ... 15.47 23.75 103.4 \n", + "4 0.1794 ... 22.88 27.66 153.2 \n", + ".. ... ... ... ... ... \n", + "490 0.1537 ... 15.30 33.17 100.2 \n", + "491 0.2149 ... 24.29 29.41 179.1 \n", + "492 0.1726 ... 25.45 26.40 166.1 \n", + "493 0.1752 ... 23.69 38.25 155.0 \n", + "494 0.1590 ... 18.98 34.12 126.7 \n", + "\n", + " worst area worst smoothness worst compactness worst concavity \\\n", + "0 1956.0 0.1238 0.1866 0.2416 \n", + "1 1709.0 0.1444 0.4245 0.4504 \n", + "2 1575.0 0.1374 0.2050 0.4000 \n", + "3 741.6 0.1791 0.5249 0.5355 \n", + "4 1606.0 0.1442 0.2576 0.3784 \n", + ".. ... ... ... ... \n", + "490 706.7 0.1241 0.2264 0.1326 \n", + "491 1819.0 0.1407 0.4186 0.6599 \n", + "492 2027.0 0.1410 0.2113 0.4107 \n", + "493 1731.0 0.1166 0.1922 0.3215 \n", + "494 1124.0 0.1139 0.3094 0.3403 \n", + "\n", + " worst concave points worst symmetry worst fractal dimension \n", + "0 0.1860 0.2750 0.08902 \n", + "1 0.2430 0.3613 0.08758 \n", + "2 0.1625 0.2364 0.07678 \n", + "3 0.1741 0.3985 0.12440 \n", + "4 0.1932 0.3063 0.08368 \n", + ".. ... ... ... \n", + "490 0.1048 0.2250 0.08321 \n", + "491 0.2542 0.2929 0.09873 \n", + "492 0.2216 0.2060 0.07115 \n", + "493 0.1628 0.2572 0.06637 \n", + "494 0.1418 0.2218 0.07820 \n", + "\n", + "[495 rows x 31 columns]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/plain": [ + "495" + ] + }, + "execution_count": 28, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "new_df = df.drop(outliers,axis = 0).reset_index(drop = False)\n", + "display(new_df)\n", + "\n", + "y_new = y[list(new_df[\"index\"])]\n", + "len(y_new)" + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[ 2.20446536, -0.28261218, 2.06835079, ..., 1.36512913,\n", + " -0.17708262, 0.52461532],\n", + " [ 1.91497191, 0.5956785 , 1.92875368, ..., 2.34544773,\n", + " 1.56196975, 0.42458997],\n", + " [ 2.11235381, -1.14828374, 2.17425205, ..., 0.9609627 ,\n", + " -0.95492065, -0.32560022],\n", + " ...,\n", + " [ 2.53014549, 0.88339441, 2.50639691, ..., 1.97739829,\n", + " -1.56751847, -0.71667159],\n", + " [ 2.05971864, 2.36235515, 1.986518 , ..., 0.96612227,\n", + " -0.53577477, -1.04870021],\n", + " [ 0.89845514, 2.31945015, 0.88418216, ..., 0.60495226,\n", + " -1.24912881, -0.22696411]])" + ] + }, + "execution_count": 29, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "X_new = new_df.drop('index', axis = 1)\n", + "\n", + "from sklearn.preprocessing import StandardScaler, MinMaxScaler\n", + "X_scaled = StandardScaler().fit_transform(X_new)\n", + "X_scaled" + ] + }, + { + "cell_type": "code", + "execution_count": 35, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "LogisticRegression(C=1.0, class_weight=None, dual=False, fit_intercept=True,\n", + " intercept_scaling=1, l1_ratio=None, max_iter=100,\n", + " multi_class='auto', n_jobs=-1, penalty='l2', random_state=42,\n", + " solver='lbfgs', tol=0.0001, verbose=0, warm_start=False)" + ] + }, + "execution_count": 35, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "cv[\"estimator\"][0]" + ] + }, + { + "cell_type": "code", + "execution_count": 36, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Mean training accuracy: 0.9739630184907546\n", + "Test accuracy: 0.9798657718120806\n" + ] + } + ], + "source": [ + "from sklearn.model_selection import train_test_split, cross_validate\n", + "\n", + "#Scaling and outlier removed\n", + "X_train, X_test, y_train, y_test = train_test_split(X_scaled,y_new, test_size=0.3, random_state=42)\n", + "\n", + "models = LogisticRegression(random_state=42, n_jobs=-1)\n", + "cv = cross_validate(models,X_train,y_train,cv = 3, n_jobs=-1, return_estimator=True)\n", + "\n", + "print(\"Mean training accuracy: {}\".format(np.mean(cv['test_score'])))\n", + "print(\"Test accuracy: {}\".format(cv[\"estimator\"][0].score(X_test,y_test)))" + ] + }, + { + "cell_type": "code", + "execution_count": 37, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "from sklearn.metrics import confusion_matrix\n", + "import matplotlib.pyplot as plt\n", + "import seaborn as sns\n", + "pred = cv[\"estimator\"][0].predict(X_test)\n", + "\n", + "cm = confusion_matrix(y_test, pred)\n", + "plt.figure(figsize=(12, 8))\n", + "ax =sns.heatmap(cm, square=True, annot=True, cbar=False)\n", + "ax.xaxis.set_ticklabels([\"False\",\"True\"], fontsize = 12)\n", + "ax.yaxis.set_ticklabels([\"False\",\"True\"], fontsize = 12, rotation=0)\n", + "ax.set_xlabel('Predicted Labels',fontsize = 15)\n", + "ax.set_ylabel('True Labels',fontsize = 15)\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 38, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Mean training accuracy: 0.944691273638642\n", + "Test accuracy: 0.9707602339181286\n" + ] + } + ], + "source": [ + "# Without any preprocess \n", + "X_train, X_test, y_train, y_test = train_test_split(X,y, test_size=0.3, random_state=42)\n", + "\n", + "models = LogisticRegression(random_state=42,n_jobs=-1)\n", + "cv = cross_validate(models,X_train,y_train,cv = 3, n_jobs=-1, return_estimator=True)\n", + "\n", + "print(\"Mean training accuracy: {}\".format(np.mean(cv['test_score'])))\n", + "print(\"Test accuracy: {}\".format(cv[\"estimator\"][0].score(X_test,y_test)))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Evaluation Metrics" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "![](img/acc.png)\n", + "\n", + "F1-score = $F_1 = 2 * \\frac{precision\\,*\\,recall}{precision\\, +\\, recall}$" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Find all evaluation metrics in sklearn library by clicking [here.](https://scikit-learn.org/stable/modules/model_evaluation.html)" + ] + }, + { + "cell_type": "code", + "execution_count": 39, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " precision recall f1-score support\n", + "\n", + " 0 0.98 0.94 0.96 63\n", + " 1 0.96 0.99 0.98 108\n", + "\n", + " accuracy 0.97 171\n", + " macro avg 0.97 0.96 0.97 171\n", + "weighted avg 0.97 0.97 0.97 171\n", + "\n" + ] + } + ], + "source": [ + "from sklearn.metrics import classification_report\n", + "print(classification_report(y_test, cv[\"estimator\"][0].predict(X_test)))" + ] + }, + { + "cell_type": "code", + "execution_count": 35, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Accuracy: 0.9707602339181286\n", + "Precision: 0.963963963963964\n", + "Recall: 0.9907407407407407\n", + "F1 Score: 0.9771689497716894\n" + ] + } + ], + "source": [ + "from sklearn.metrics import f1_score, accuracy_score, recall_score, precision_score\n", + "\n", + "final_model = cv[\"estimator\"][0]\n", + "\n", + "y_pred = final_model.predict(X_test)\n", + "\n", + "print(\"Accuracy:\",accuracy_score(y_test,y_pred))\n", + "print(\"Precision:\",precision_score(y_test,y_pred))\n", + "print(\"Recall:\",recall_score(y_test,y_pred))\n", + "print(\"F1 Score:\",f1_score(y_test,y_pred))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**When to use Accuracy Metric** \n", + "When there are roughly equal number of samples belonging to each class. \n", + "
\n", + "**When to use Precision** \n", + "Precision is a good measure to determine, when the costs of False Positive is high. For instance, email spam detection. In email spam detection, a false positive means that an email that is non-spam (actual negative) has been identified as spam (predicted spam). The email user might lose important emails if the precision is not high for the spam detection model. \n", + "
\n", + "**When to use Recall** \n", + "For instance, in fraud detection or sick patient detection. If a fraudulent transaction (Actual Positive) is predicted as non-fraudulent (Predicted Negative), the consequence can be very bad for the bank. \n", + "
\n", + "**When to use F1 Score** \n", + "F1 Score might be a better measure to use if we need to seek a balance between Precision and Recall AND there is an uneven class distribution (large number of Actual Negatives)." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### ROC (Receiver Operating Characteristic) & AUC (Area Under the Curve)\n", + "AUC - ROC curve is a performance measurement for classification problem at various thresholds settings. ROC is a probability curve and AUC represents degree or measure of separability. It tells how much model is capable of distinguishing between classes. Higher the AUC, better the model is at predicting 0s as 0s and 1s as 1s. \n", + "\n", + "**True Positive Rate (TPR)** = $TP\\,/\\,(TP+FN)$ \n", + "**False Positive Rate (FPR)** = $FP\\,/\\,(FP+FN)$" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "![](img/roc.png)" + ] + }, + { + "cell_type": "code", + "execution_count": 40, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "from sklearn.metrics import roc_curve, auc\n", + "\n", + "y_pred_prop = final_model.predict_proba(X_test)[:,1]\n", + "\n", + "fpr_log, tpr_log, _ = roc_curve(y_test, y_pred_prop)\n", + "roc_auc_log = auc(fpr_log, tpr_log)\n", + "\n", + "sns.set_style(\"white\")\n", + "plt.figure(figsize=(10, 7))\n", + "plt.plot(fpr_log, tpr_log, color='darkorange',\n", + " label='ROC curve (area = %0.2f)' % roc_auc_log)\n", + "plt.plot([0, 1], [0, 1], color='navy', linestyle='--')\n", + "plt.xlim([0.0, 1.0])\n", + "plt.ylim([0.0, 1.05])\n", + "plt.xlabel('False Positive Rate',fontsize=18,labelpad =10)\n", + "plt.ylabel('True Positive Rate',fontsize=18)\n", + "plt.title('Receiver Operating Characteristic',fontsize=22).set_position([.5, 1.02])\n", + "plt.legend(loc=\"lower right\",fontsize=13)\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Resources\n", + "https://www.analyticsvidhya.com/blog/2020/10/how-to-choose-evaluation-metrics-for-classification-model/ \n", + "https://www.kaggle.com/vipulgandhi/how-to-choose-right-metric-for-evaluating-ml-model\n" + ] + } + ], + "metadata": { + "colab": { + "collapsed_sections": [ + "MFiCsRxRledE" + ], + "include_colab_link": true, + "name": "logisticRegression.ipynb", + "provenance": [] + }, + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.7.3" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/Logistic Regression/logistic_regression.ipynb b/Logistic Regression/logistic_regression.ipynb index 33fd463..bffbdee 100644 --- a/Logistic Regression/logistic_regression.ipynb +++ b/Logistic Regression/logistic_regression.ipynb @@ -674,7 +674,7 @@ }, { "cell_type": "code", - "execution_count": 20, + "execution_count": 1, "metadata": {}, "outputs": [ { @@ -886,7 +886,7 @@ "[5 rows x 30 columns]" ] }, - "execution_count": 20, + "execution_count": 1, "metadata": {}, "output_type": "execute_result" } @@ -2103,7 +2103,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.7.3" + "version": "3.7.9" } }, "nbformat": 4, diff --git a/Probabilty/.ipynb_checkpoints/probability-checkpoint.ipynb b/Probabilty/.ipynb_checkpoints/probability-checkpoint.ipynb new file mode 100644 index 0000000..50011b3 --- /dev/null +++ b/Probabilty/.ipynb_checkpoints/probability-checkpoint.ipynb @@ -0,0 +1,464 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + " \"Open\n", + "" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "ii6SZ-Urv_QC" + }, + "source": [ + "![](img/logo.png)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "XT3n8LW2v_QD" + }, + "source": [ + "
All rights reserved ©️ Global AI Hub 2020
" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "AtuZFrxtv_QE" + }, + "source": [ + "# Probability Review\n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "gxybYIfjv_QE" + }, + "source": [ + "Probability is the branch of mathematics concerning numerical descriptions of how likely an event is to occur, or how likely it is that a proposition is true. The probability of an event is a number between 0 and 1, where, roughly speaking, 0 indicates impossibility of the event and 1 indicates certainty. " + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "BXHonzRLv_QF" + }, + "source": [ + "## Random Variables" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "aWcCllckv_QF" + }, + "source": [ + "A random variable is a variable that can take on different values randomly. We typically denote the random variable itself with a lowercase letter in plain typeface, and the values it can take on with lowercase script letters. For example, x1 and x2 are both possible values that the random variable x can take on. For vector-valued variables, we would write the random variable as x and one of its values as x. On its own, a random variable is just a description of the states that are possible; it must be coupled with a probability distribution that specifies how likely each of these states are. " + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "kGyrELttv_QF" + }, + "source": [ + "Random variables may be discrete or continuous. A discrete random variable is one that has a finite or countably infinite number of states. Note that these states are not necessarily the integers; they can also just be named states that are not considered to have any numerical value. A continuous random variable is associated with a real value." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "94UfigFgv_QG" + }, + "source": [ + "## Probability Distributions" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "Pvg9bB81v_QG" + }, + "source": [ + "A probability distributionis a description of how likely a random variable or set of random variables is to take on each of its possible states. The way we describe probability distributions depends on whether the variables are discrete or continuous." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "Go2MuuxPv_QH" + }, + "source": [ + "![Prob](img/1.png) " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "![Prob](img/discont.png)\n", + "
Discrete vs Continuous
" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "iIgRi-sFv_QI" + }, + "source": [ + "### Discrete Variables and Probability Mass Functions" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "sG9RAchlv_QI" + }, + "source": [ + "A probability distribution over discrete variables can be explained using a probability mass function (PMF). We typically express probability mass functions with a capital P. Usually, we associate each random variable with a different probability mass function, and the reader must determine which PMF to use based on the identity of the random variable instead of the name of the function; P (x) is generally not the same as P (y)." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "![Prob](img/dis2.png)\n", + "
Probability Mass Function
" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "jNTwrtSNv_QJ" + }, + "source": [ + "### Continuous Variables and Probability Density Functions" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "Ms0drg0hv_QJ" + }, + "source": [ + "When working with continuous random variables, we describe probability distributions using a probability density function (PDF) rather than a probability mass function. To be a probability density function, a function p must satisfy the following properties:" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "tdrk1T9_v_QK" + }, + "source": [ + "1. The domain of p must be the set of all possible states of x\n", + "2. ∀x ∈ x, p(x) ≥ 0. Note that we do not require $p(x)\\leq1$\n", + "3. $\\int_a^bp(x)dx = 1$" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "![Prob](img/cont1.jpg)\n", + "
Probability Mass Function
" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "![Prob](img/overview-prob-distr.png)\n", + "
Types of Probabilty Distributions
" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "TBwKOZJjv_QK" + }, + "source": [ + "## Marginal & Conditional Prob." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "hqkMsDRxv_QK" + }, + "source": [ + "### Marginal Probability" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The probability of one event in the presence of all (or a subset of) outcomes of the other random variable is called the marginal probability or the marginal distribution. The marginal probability of one random variable in the presence of additional random variables is referred to as the marginal probability distribution." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "k_k47V_Lv_QL" + }, + "source": [ + "

$P(X=A) = \\sum_{i} P(X=A, Y=yi)$ for all Y

" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "![](img/mar_prob.png)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "nikQKlFov_QM" + }, + "source": [ + "### Conditional Probability" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "nDnE6ng2v_QM" + }, + "source": [ + "The probability of one event given the occurrence of another event is called the *conditional probability*. The conditional probability of one to one or more random variables is referred to as the conditional probability distribution." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "2qGGdCbOv_QN" + }, + "source": [ + "

P(A given B) = P(A | B)

" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "![](img/cond.png)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "WnMS5VHZv_QN" + }, + "source": [ + "## Independence" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "PspPmXhIv_QN" + }, + "source": [ + "If one variable is not dependent on a second variable, this is called *independence* or *statistical independence*. For example, we may be interested in the joint probability of independent events A and B, which is the same as the probability of A and the probability of B.\n", + "\n", + "Probabilities are combined using multiplication, therefore the joint probability of independent events is calculated as the probability of event A multiplied by the probability of event B" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "J_bfibLxv_QO" + }, + "source": [ + "

P(A and B) = P(A) * P(B)

" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "i-Ey-Okqv_QO" + }, + "source": [ + "## Expectation, Variance, Covariance" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "v3-ybw0pv_QP" + }, + "source": [ + "### Expectation" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "QCdKv7l7v_QP" + }, + "source": [ + "The expectation, or expected value, of some function f(x) with respect to a probability distribution P(x) is the average, or mean value, that f takes on when x is drawn from P. For discrete variables this can be computed with a summation:" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "NkTPlaYlv_QP" + }, + "source": [ + "

$\\mathrm{E[x]}=\\sum_{n=a}^{b}P(x)f(x)$

" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "Q1uvuv-Uv_QQ" + }, + "source": [ + "while for continuous variables, it is computed with an integral:" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "5m7Y6DYNv_QQ" + }, + "source": [ + "

$\\mathrm{E[x]}=\\int_a^bP(x)f(x)dx$

\n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "NIP-7_H_v_QR" + }, + "source": [ + "### Variance" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "Qtk6rkZgv_QR" + }, + "source": [ + "The variance gives a measure of how much the values of a function of a random variable x vary as we sample different values of x from its probability distribution. It measures how far a set of numbers is spread out from their average value:" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "JLSSJ6OGv_QR" + }, + "source": [ + "

$\\mathrm{Var[x]}= \\mathrm{E[(x-\\mathrm{E[x]})^2]}$

" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "FyVcGE3sv_QS" + }, + "source": [ + "When the variance is low, the values of f(x) cluster near their expected value. The Square root of the variance is known as the *standard deviation*." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "vsOWKwInv_QS" + }, + "source": [ + "### Covariance" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "hi96QNs-v_QT" + }, + "source": [ + "In probability, covariance is the measure of the joint probability for two random variables. It describes how the two variables change together.\n", + "\n", + "It is denoted as the function cov(X, Y), where X and Y are the two random variables being considered." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "OABR2Q74v_QT" + }, + "source": [ + "

$\\mathrm{Cov[x,y]}=\\mathrm{E[(x-\\mathrm{E[x]})(y-\\mathrm{E[y]})]}$

" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "O6qt5FFMv_QU" + }, + "source": [ + "## Bayes' Rule " + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "47SaOhn_v_QU" + }, + "source": [ + "In probability theory and statistics, Bayes's theorem (alternatively Bayes's law or Bayes's rule) describes the probability of an event, based on prior knowledge of conditions that might be related to the event. For example, if the risk of developing health problems is known to increase with age, Bayes's theorem allows the risk to an individual of a known age to be assessed more accurately than simply assuming that the individual is typical of the population as a whole." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "saCaM_Vfv_QU" + }, + "source": [ + "We often find ourselves in a situation where we know P(y | x) and need to know P(x | y). Fortunately, if we also know P(x), we can compute the desired quantity using Bayes’ rule:" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "![](img/bayes.jpeg)" + ] + } + ], + "metadata": { + "colab": { + "name": "probability.ipynb", + "provenance": [] + }, + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.7.3" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/Probabilty/probability.ipynb b/Probabilty/probability.ipynb index 50011b3..28fb0e3 100644 --- a/Probabilty/probability.ipynb +++ b/Probabilty/probability.ipynb @@ -456,7 +456,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.7.3" + "version": "3.7.9" } }, "nbformat": 4, diff --git a/Project/.ipynb_checkpoints/09-11-2020 ML Course Nigeria Project 'name'-checkpoint.ipynb b/Project/.ipynb_checkpoints/09-11-2020 ML Course Nigeria Project 'name'-checkpoint.ipynb new file mode 100644 index 0000000..9fbf733 --- /dev/null +++ b/Project/.ipynb_checkpoints/09-11-2020 ML Course Nigeria Project 'name'-checkpoint.ipynb @@ -0,0 +1,1231 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Project\n", + "\n", + "In this project, our aim is to building a model for predicting churn. Churn is the percentage of customers that stopped using your company's product or service during a certain time frame. Thus, in the given dataset, our label will be `Churn` column.\n", + "\n", + "## Steps\n", + "- Read the `churn.csv` file and describe it.\n", + "- Make at least 4 different analysis on Exploratory Data Analysis section.\n", + "- Pre-process the dataset to get ready for ML application. (Check missing data and handle them, can we need to do scaling or feature extraction etc.)\n", + "- Define appropriate evaluation metric for our case (classification).\n", + "- Train and evaluate Logistic Regression, Decision Trees and one other appropriate algorithm which you can choose from scikit-learn library.\n", + "- Is there any overfitting and underfitting? Interpret your results and try to overcome if there is any problem in a new section.\n", + "- Create confusion metrics for each algorithm and display Accuracy, Recall, Precision and F1-Score values.\n", + "- Analyse and compare results of 3 algorithms.\n", + "- Select best performing model based on evaluation metric you chose on test dataset.\n", + "\n", + "\n", + "Good luck :)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "

Your Name

" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Data" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import pandas as pd\n", + "import seaborn as sns\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
ChurnAccountWeeksContractRenewalDataPlanDataUsageCustServCallsDayMinsDayCallsMonthlyChargeOverageFeeRoamMins
00128112.71265.111089.09.8710.0
10107113.71161.612382.09.7813.7
20137100.00243.411452.06.0612.2
3084000.02299.47157.03.106.6
4075000.03166.711341.07.4210.1
\n", + "
" + ], + "text/plain": [ + " Churn AccountWeeks ContractRenewal DataPlan DataUsage CustServCalls \\\n", + "0 0 128 1 1 2.7 1 \n", + "1 0 107 1 1 3.7 1 \n", + "2 0 137 1 0 0.0 0 \n", + "3 0 84 0 0 0.0 2 \n", + "4 0 75 0 0 0.0 3 \n", + "\n", + " DayMins DayCalls MonthlyCharge OverageFee RoamMins \n", + "0 265.1 110 89.0 9.87 10.0 \n", + "1 161.6 123 82.0 9.78 13.7 \n", + "2 243.4 114 52.0 6.06 12.2 \n", + "3 299.4 71 57.0 3.10 6.6 \n", + "4 166.7 113 41.0 7.42 10.1 " + ] + }, + "execution_count": 2, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Read csv\n", + "data = pd.read_csv(\"churn.csv\")\n", + "data.head()" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [], + "source": [ + "# Describe our data for each feature and use .info() for get information about our dataset\n", + "# Analys missing values" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(3333, 11)" + ] + }, + "execution_count": 10, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "data.shape" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "RangeIndex: 3333 entries, 0 to 3332\n", + "Data columns (total 11 columns):\n", + " # Column Non-Null Count Dtype \n", + "--- ------ -------------- ----- \n", + " 0 Churn 3333 non-null int64 \n", + " 1 AccountWeeks 3333 non-null int64 \n", + " 2 ContractRenewal 3333 non-null int64 \n", + " 3 DataPlan 3333 non-null int64 \n", + " 4 DataUsage 3333 non-null float64\n", + " 5 CustServCalls 3333 non-null int64 \n", + " 6 DayMins 3333 non-null float64\n", + " 7 DayCalls 3333 non-null int64 \n", + " 8 MonthlyCharge 3333 non-null float64\n", + " 9 OverageFee 3333 non-null float64\n", + " 10 RoamMins 3333 non-null float64\n", + "dtypes: float64(5), int64(6)\n", + "memory usage: 286.6 KB\n" + ] + } + ], + "source": [ + "data.info()" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Churn 0\n", + "AccountWeeks 0\n", + "ContractRenewal 0\n", + "DataPlan 0\n", + "DataUsage 0\n", + "CustServCalls 0\n", + "DayMins 0\n", + "DayCalls 0\n", + "MonthlyCharge 0\n", + "OverageFee 0\n", + "RoamMins 0\n", + "dtype: int64" + ] + }, + "execution_count": 14, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "data.isna().sum()" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Churn 0\n", + "AccountWeeks 0\n", + "ContractRenewal 0\n", + "DataPlan 0\n", + "DataUsage 0\n", + "CustServCalls 0\n", + "DayMins 0\n", + "DayCalls 0\n", + "MonthlyCharge 0\n", + "OverageFee 0\n", + "RoamMins 0\n", + "dtype: int64" + ] + }, + "execution_count": 15, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "data.isin(['?']).sum()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "From the above, the data have 3333 rows and 11 column and it is revealed that there is no missing value in our data" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
ChurnAccountWeeksContractRenewalDataPlanDataUsageCustServCallsDayMinsDayCallsMonthlyChargeOverageFeeRoamMins
count3333.0000003333.0000003333.0000003333.0000003333.0000003333.0000003333.0000003333.0000003333.0000003333.0000003333.000000
mean0.144914101.0648060.9030900.2766280.8164751.562856179.775098100.43564456.30516110.05148810.237294
std0.35206739.8221060.2958790.4473981.2726681.31549154.46738920.06908416.4260322.5357122.791840
min0.0000001.0000000.0000000.0000000.0000000.0000000.0000000.00000014.0000000.0000000.000000
25%0.00000074.0000001.0000000.0000000.0000001.000000143.70000087.00000045.0000008.3300008.500000
50%0.000000101.0000001.0000000.0000000.0000001.000000179.400000101.00000053.50000010.07000010.300000
75%0.000000127.0000001.0000001.0000001.7800002.000000216.400000114.00000066.20000011.77000012.100000
max1.000000243.0000001.0000001.0000005.4000009.000000350.800000165.000000111.30000018.19000020.000000
\n", + "
" + ], + "text/plain": [ + " Churn AccountWeeks ContractRenewal DataPlan DataUsage \\\n", + "count 3333.000000 3333.000000 3333.000000 3333.000000 3333.000000 \n", + "mean 0.144914 101.064806 0.903090 0.276628 0.816475 \n", + "std 0.352067 39.822106 0.295879 0.447398 1.272668 \n", + "min 0.000000 1.000000 0.000000 0.000000 0.000000 \n", + "25% 0.000000 74.000000 1.000000 0.000000 0.000000 \n", + "50% 0.000000 101.000000 1.000000 0.000000 0.000000 \n", + "75% 0.000000 127.000000 1.000000 1.000000 1.780000 \n", + "max 1.000000 243.000000 1.000000 1.000000 5.400000 \n", + "\n", + " CustServCalls DayMins DayCalls MonthlyCharge OverageFee \\\n", + "count 3333.000000 3333.000000 3333.000000 3333.000000 3333.000000 \n", + "mean 1.562856 179.775098 100.435644 56.305161 10.051488 \n", + "std 1.315491 54.467389 20.069084 16.426032 2.535712 \n", + "min 0.000000 0.000000 0.000000 14.000000 0.000000 \n", + "25% 1.000000 143.700000 87.000000 45.000000 8.330000 \n", + "50% 1.000000 179.400000 101.000000 53.500000 10.070000 \n", + "75% 2.000000 216.400000 114.000000 66.200000 11.770000 \n", + "max 9.000000 350.800000 165.000000 111.300000 18.190000 \n", + "\n", + " RoamMins \n", + "count 3333.000000 \n", + "mean 10.237294 \n", + "std 2.791840 \n", + "min 0.000000 \n", + "25% 8.500000 \n", + "50% 10.300000 \n", + "75% 12.100000 \n", + "max 20.000000 " + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "data.describe()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Exploratory Data Analysis" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 16, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# Our label Distribution (countplot)\n", + "sns.countplot(x='Churn', data=data)" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# Example EDA\n" + ] + }, + { + "cell_type": "code", + "execution_count": 46, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "fig = plt.figure(figsize = (20, 25))\n", + "name = list('AccountWeeks', 'ContractRenewal', \"DataPlan\", \"DataUsage\", 'CustServCalls', 'DayMins', 'DayCalls', 'MonthlyCharge', 'OverageFee', 'RoamMins')\n", + "data.hist()\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 47, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
ChurnAccountWeeksContractRenewalDataPlanCustServCallsDayMinsDayCallsMonthlyChargeOverageFeeRoamMins
Churn1.0000000.016541-0.259852-0.1021480.2087500.2051510.0184590.0723130.0928120.068239
AccountWeeks0.0165411.000000-0.0247350.002918-0.0037960.0062160.0384700.012581-0.0067490.009514
ContractRenewal-0.259852-0.0247351.000000-0.0060060.024522-0.049396-0.003755-0.047291-0.019105-0.045871
DataPlan-0.1021480.002918-0.0060061.000000-0.017824-0.001684-0.0110860.7374900.021526-0.001318
CustServCalls0.208750-0.0037960.024522-0.0178241.000000-0.013423-0.018942-0.028017-0.012964-0.009640
DayMins0.2051510.006216-0.049396-0.001684-0.0134231.0000000.0067500.5679680.007038-0.010155
DayCalls0.0184590.038470-0.003755-0.011086-0.0189420.0067501.000000-0.007963-0.0214490.021565
MonthlyCharge0.0723130.012581-0.0472910.737490-0.0280170.567968-0.0079631.0000000.2817660.117433
OverageFee0.092812-0.006749-0.0191050.021526-0.0129640.007038-0.0214490.2817661.000000-0.011023
RoamMins0.0682390.009514-0.045871-0.001318-0.009640-0.0101550.0215650.117433-0.0110231.000000
\n", + "
" + ], + "text/plain": [ + " Churn AccountWeeks ContractRenewal DataPlan \\\n", + "Churn 1.000000 0.016541 -0.259852 -0.102148 \n", + "AccountWeeks 0.016541 1.000000 -0.024735 0.002918 \n", + "ContractRenewal -0.259852 -0.024735 1.000000 -0.006006 \n", + "DataPlan -0.102148 0.002918 -0.006006 1.000000 \n", + "CustServCalls 0.208750 -0.003796 0.024522 -0.017824 \n", + "DayMins 0.205151 0.006216 -0.049396 -0.001684 \n", + "DayCalls 0.018459 0.038470 -0.003755 -0.011086 \n", + "MonthlyCharge 0.072313 0.012581 -0.047291 0.737490 \n", + "OverageFee 0.092812 -0.006749 -0.019105 0.021526 \n", + "RoamMins 0.068239 0.009514 -0.045871 -0.001318 \n", + "\n", + " CustServCalls DayMins DayCalls MonthlyCharge OverageFee \\\n", + "Churn 0.208750 0.205151 0.018459 0.072313 0.092812 \n", + "AccountWeeks -0.003796 0.006216 0.038470 0.012581 -0.006749 \n", + "ContractRenewal 0.024522 -0.049396 -0.003755 -0.047291 -0.019105 \n", + "DataPlan -0.017824 -0.001684 -0.011086 0.737490 0.021526 \n", + "CustServCalls 1.000000 -0.013423 -0.018942 -0.028017 -0.012964 \n", + "DayMins -0.013423 1.000000 0.006750 0.567968 0.007038 \n", + "DayCalls -0.018942 0.006750 1.000000 -0.007963 -0.021449 \n", + "MonthlyCharge -0.028017 0.567968 -0.007963 1.000000 0.281766 \n", + "OverageFee -0.012964 0.007038 -0.021449 0.281766 1.000000 \n", + "RoamMins -0.009640 -0.010155 0.021565 0.117433 -0.011023 \n", + "\n", + " RoamMins \n", + "Churn 0.068239 \n", + "AccountWeeks 0.009514 \n", + "ContractRenewal -0.045871 \n", + "DataPlan -0.001318 \n", + "CustServCalls -0.009640 \n", + "DayMins -0.010155 \n", + "DayCalls 0.021565 \n", + "MonthlyCharge 0.117433 \n", + "OverageFee -0.011023 \n", + "RoamMins 1.000000 " + ] + }, + "execution_count": 47, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "data.corr()" + ] + }, + { + "cell_type": "code", + "execution_count": 48, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 48, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "corr = data.corr()\n", + "sns.heatmap(corr)" + ] + }, + { + "cell_type": "code", + "execution_count": 49, + "metadata": {}, + "outputs": [], + "source": [ + "columns = np.full((corr.shape[0],), True, dtype=bool)\n", + "for i in range(corr.shape[0]):\n", + " for j in range(i+1, corr.shape[0]):\n", + " if corr.iloc[i,j] >= 0.9:\n", + " if columns[j]:\n", + " columns[j] = False" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 24, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "data['AccountWeeks'].hist()" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
ChurnAccountWeeksContractRenewalDataPlanDataUsageCustServCallsDayMinsDayCallsMonthlyChargeOverageFeeRoamMins
Churn1.0000000.016541-0.259852-0.102148-0.0871950.2087500.2051510.0184590.0723130.0928120.068239
AccountWeeks0.0165411.000000-0.0247350.0029180.014391-0.0037960.0062160.0384700.012581-0.0067490.009514
ContractRenewal-0.259852-0.0247351.000000-0.006006-0.0192230.024522-0.049396-0.003755-0.047291-0.019105-0.045871
DataPlan-0.1021480.002918-0.0060061.0000000.945982-0.017824-0.001684-0.0110860.7374900.021526-0.001318
DataUsage-0.0871950.014391-0.0192230.9459821.000000-0.0217230.003176-0.0079620.7816600.0196370.162746
CustServCalls0.208750-0.0037960.024522-0.017824-0.0217231.000000-0.013423-0.018942-0.028017-0.012964-0.009640
DayMins0.2051510.006216-0.049396-0.0016840.003176-0.0134231.0000000.0067500.5679680.007038-0.010155
DayCalls0.0184590.038470-0.003755-0.011086-0.007962-0.0189420.0067501.000000-0.007963-0.0214490.021565
MonthlyCharge0.0723130.012581-0.0472910.7374900.781660-0.0280170.567968-0.0079631.0000000.2817660.117433
OverageFee0.092812-0.006749-0.0191050.0215260.019637-0.0129640.007038-0.0214490.2817661.000000-0.011023
RoamMins0.0682390.009514-0.045871-0.0013180.162746-0.009640-0.0101550.0215650.117433-0.0110231.000000
\n", + "
" + ], + "text/plain": [ + " Churn AccountWeeks ContractRenewal DataPlan DataUsage \\\n", + "Churn 1.000000 0.016541 -0.259852 -0.102148 -0.087195 \n", + "AccountWeeks 0.016541 1.000000 -0.024735 0.002918 0.014391 \n", + "ContractRenewal -0.259852 -0.024735 1.000000 -0.006006 -0.019223 \n", + "DataPlan -0.102148 0.002918 -0.006006 1.000000 0.945982 \n", + "DataUsage -0.087195 0.014391 -0.019223 0.945982 1.000000 \n", + "CustServCalls 0.208750 -0.003796 0.024522 -0.017824 -0.021723 \n", + "DayMins 0.205151 0.006216 -0.049396 -0.001684 0.003176 \n", + "DayCalls 0.018459 0.038470 -0.003755 -0.011086 -0.007962 \n", + "MonthlyCharge 0.072313 0.012581 -0.047291 0.737490 0.781660 \n", + "OverageFee 0.092812 -0.006749 -0.019105 0.021526 0.019637 \n", + "RoamMins 0.068239 0.009514 -0.045871 -0.001318 0.162746 \n", + "\n", + " CustServCalls DayMins DayCalls MonthlyCharge OverageFee \\\n", + "Churn 0.208750 0.205151 0.018459 0.072313 0.092812 \n", + "AccountWeeks -0.003796 0.006216 0.038470 0.012581 -0.006749 \n", + "ContractRenewal 0.024522 -0.049396 -0.003755 -0.047291 -0.019105 \n", + "DataPlan -0.017824 -0.001684 -0.011086 0.737490 0.021526 \n", + "DataUsage -0.021723 0.003176 -0.007962 0.781660 0.019637 \n", + "CustServCalls 1.000000 -0.013423 -0.018942 -0.028017 -0.012964 \n", + "DayMins -0.013423 1.000000 0.006750 0.567968 0.007038 \n", + "DayCalls -0.018942 0.006750 1.000000 -0.007963 -0.021449 \n", + "MonthlyCharge -0.028017 0.567968 -0.007963 1.000000 0.281766 \n", + "OverageFee -0.012964 0.007038 -0.021449 0.281766 1.000000 \n", + "RoamMins -0.009640 -0.010155 0.021565 0.117433 -0.011023 \n", + "\n", + " RoamMins \n", + "Churn 0.068239 \n", + "AccountWeeks 0.009514 \n", + "ContractRenewal -0.045871 \n", + "DataPlan -0.001318 \n", + "DataUsage 0.162746 \n", + "CustServCalls -0.009640 \n", + "DayMins -0.010155 \n", + "DayCalls 0.021565 \n", + "MonthlyCharge 0.117433 \n", + "OverageFee -0.011023 \n", + "RoamMins 1.000000 " + ] + }, + "execution_count": 17, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "data.corr()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Preprocessing\n", + "\n", + "- Are there any duplicated values?\n", + "- Do we need to do feature scaling?\n", + "- Do we need to generate new features?\n", + "- Split Train and Test dataset. (0.7/0.3)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# ML Application\n", + "\n", + "- Define models.\n", + "- Fit models.\n", + "- Evaluate models for both train and test dataset.\n", + "- Generate Confusion Matrix and scores of Accuracy, Recall, Precision and F1-Score.\n", + "- Analyse occurrence of overfitting and underfitting. If there is any of them, try to overcome it within a different section." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Evaluation\n", + "\n", + "- Select the best performing model and write your comments about why choose this model.\n", + "- Analyse results and make comment about how you can improve model." + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.7.9" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/Project/09-11-2020 ML Course Nigeria Project 'name'.ipynb b/Project/09-11-2020 ML Course Nigeria Project 'name'.ipynb index 1856d7e..3db6828 100644 --- a/Project/09-11-2020 ML Course Nigeria Project 'name'.ipynb +++ b/Project/09-11-2020 ML Course Nigeria Project 'name'.ipynb @@ -39,19 +39,28 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 189, "metadata": {}, "outputs": [], "source": [ "import pandas as pd\n", "import seaborn as sns\n", "import numpy as np\n", - "import matplotlib.pyplot as plt" + "import matplotlib.pyplot as plt\n", + "\n", + "from sklearn.preprocessing import LabelEncoder\n", + "from sklearn.model_selection import train_test_split\n", + "from sklearn.metrics import accuracy_score\n", + "from sklearn.metrics import confusion_matrix, classification_report\n", + "from sklearn.preprocessing import StandardScaler, MinMaxScaler\n", + "from sklearn.tree import DecisionTreeClassifier\n", + "from sklearn.linear_model import LogisticRegression\n", + "from sklearn import svm" ] }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 132, "metadata": {}, "outputs": [ { @@ -179,7 +188,7 @@ "4 166.7 113 41.0 7.42 10.1 " ] }, - "execution_count": 5, + "execution_count": 132, "metadata": {}, "output_type": "execute_result" } @@ -192,7 +201,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 133, "metadata": {}, "outputs": [], "source": [ @@ -201,62 +210,350 @@ ] }, { - "cell_type": "markdown", + "cell_type": "code", + "execution_count": 134, "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(3333, 11)" + ] + }, + "execution_count": 134, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ - "# Exploratory Data Analysis" + "data.shape" + ] + }, + { + "cell_type": "code", + "execution_count": 135, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "RangeIndex: 3333 entries, 0 to 3332\n", + "Data columns (total 11 columns):\n", + " # Column Non-Null Count Dtype \n", + "--- ------ -------------- ----- \n", + " 0 Churn 3333 non-null int64 \n", + " 1 AccountWeeks 3333 non-null int64 \n", + " 2 ContractRenewal 3333 non-null int64 \n", + " 3 DataPlan 3333 non-null int64 \n", + " 4 DataUsage 3333 non-null float64\n", + " 5 CustServCalls 3333 non-null int64 \n", + " 6 DayMins 3333 non-null float64\n", + " 7 DayCalls 3333 non-null int64 \n", + " 8 MonthlyCharge 3333 non-null float64\n", + " 9 OverageFee 3333 non-null float64\n", + " 10 RoamMins 3333 non-null float64\n", + "dtypes: float64(5), int64(6)\n", + "memory usage: 286.6 KB\n" + ] + } + ], + "source": [ + "data.info()" ] }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 136, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "" + "Churn 0\n", + "AccountWeeks 0\n", + "ContractRenewal 0\n", + "DataPlan 0\n", + "DataUsage 0\n", + "CustServCalls 0\n", + "DayMins 0\n", + "DayCalls 0\n", + "MonthlyCharge 0\n", + "OverageFee 0\n", + "RoamMins 0\n", + "dtype: int64" ] }, - "execution_count": 7, + "execution_count": 136, "metadata": {}, "output_type": "execute_result" - }, + } + ], + "source": [ + "data.isna().sum()" + ] + }, + { + "cell_type": "code", + "execution_count": 137, + "metadata": {}, + "outputs": [ { "data": { - "image/png": "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\n", "text/plain": [ - "
" + "Churn 0\n", + "AccountWeeks 0\n", + "ContractRenewal 0\n", + "DataPlan 0\n", + "DataUsage 0\n", + "CustServCalls 0\n", + "DayMins 0\n", + "DayCalls 0\n", + "MonthlyCharge 0\n", + "OverageFee 0\n", + "RoamMins 0\n", + "dtype: int64" ] }, - "metadata": { - "needs_background": "light" + "execution_count": 137, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "data.isin(['?']).sum()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "From the above, the data have 3333 rows and 11 column and it is revealed that there is no missing value in our data" + ] + }, + { + "cell_type": "code", + "execution_count": 138, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
ChurnAccountWeeksContractRenewalDataPlanDataUsageCustServCallsDayMinsDayCallsMonthlyChargeOverageFeeRoamMins
count3333.0000003333.0000003333.0000003333.0000003333.0000003333.0000003333.0000003333.0000003333.0000003333.0000003333.000000
mean0.144914101.0648060.9030900.2766280.8164751.562856179.775098100.43564456.30516110.05148810.237294
std0.35206739.8221060.2958790.4473981.2726681.31549154.46738920.06908416.4260322.5357122.791840
min0.0000001.0000000.0000000.0000000.0000000.0000000.0000000.00000014.0000000.0000000.000000
25%0.00000074.0000001.0000000.0000000.0000001.000000143.70000087.00000045.0000008.3300008.500000
50%0.000000101.0000001.0000000.0000000.0000001.000000179.400000101.00000053.50000010.07000010.300000
75%0.000000127.0000001.0000001.0000001.7800002.000000216.400000114.00000066.20000011.77000012.100000
max1.000000243.0000001.0000001.0000005.4000009.000000350.800000165.000000111.30000018.19000020.000000
\n", + "
" + ], + "text/plain": [ + " Churn AccountWeeks ContractRenewal DataPlan DataUsage \\\n", + "count 3333.000000 3333.000000 3333.000000 3333.000000 3333.000000 \n", + "mean 0.144914 101.064806 0.903090 0.276628 0.816475 \n", + "std 0.352067 39.822106 0.295879 0.447398 1.272668 \n", + "min 0.000000 1.000000 0.000000 0.000000 0.000000 \n", + "25% 0.000000 74.000000 1.000000 0.000000 0.000000 \n", + "50% 0.000000 101.000000 1.000000 0.000000 0.000000 \n", + "75% 0.000000 127.000000 1.000000 1.000000 1.780000 \n", + "max 1.000000 243.000000 1.000000 1.000000 5.400000 \n", + "\n", + " CustServCalls DayMins DayCalls MonthlyCharge OverageFee \\\n", + "count 3333.000000 3333.000000 3333.000000 3333.000000 3333.000000 \n", + "mean 1.562856 179.775098 100.435644 56.305161 10.051488 \n", + "std 1.315491 54.467389 20.069084 16.426032 2.535712 \n", + "min 0.000000 0.000000 0.000000 14.000000 0.000000 \n", + "25% 1.000000 143.700000 87.000000 45.000000 8.330000 \n", + "50% 1.000000 179.400000 101.000000 53.500000 10.070000 \n", + "75% 2.000000 216.400000 114.000000 66.200000 11.770000 \n", + "max 9.000000 350.800000 165.000000 111.300000 18.190000 \n", + "\n", + " RoamMins \n", + "count 3333.000000 \n", + "mean 10.237294 \n", + "std 2.791840 \n", + "min 0.000000 \n", + "25% 8.500000 \n", + "50% 10.300000 \n", + "75% 12.100000 \n", + "max 20.000000 " + ] }, - "output_type": "display_data" + "execution_count": 138, + "metadata": {}, + "output_type": "execute_result" } ], "source": [ - "# Our label Distribution (countplot)\n" + "data.describe()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Exploratory Data Analysis" ] }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 139, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "" + "" ] }, - "execution_count": 3, + "execution_count": 139, "metadata": {}, "output_type": "execute_result" }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -268,43 +565,1750 @@ } ], "source": [ - "# Example EDA\n" + "# Our label Distribution (countplot)\n", + "sns.countplot(x='Churn', data=data)" ] }, { - "cell_type": "markdown", + "cell_type": "code", + "execution_count": 140, "metadata": {}, + "outputs": [], "source": [ - "# Preprocessing\n", - "\n", - "- Are there any duplicated values?\n", - "- Do we need to do feature scaling?\n", - "- Do we need to generate new features?\n", - "- Split Train and Test dataset. (0.7/0.3)" + "# Example EDA\n" ] }, { - "cell_type": "markdown", + "cell_type": "code", + "execution_count": 141, "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], "source": [ - "# ML Application\n", - "\n", - "- Define models.\n", - "- Fit models.\n", - "- Evaluate models for both train and test dataset.\n", - "- Generate Confusion Matrix and scores of Accuracy, Recall, Precision and F1-Score.\n", - "- Analyse occurrence of overfitting and underfitting. If there is any of them, try to overcome it within a different section." + "#fig = plt.figure(figsize = (30, 25))\n", + "#name = list('AccountWeeks', 'ContractRenewal', \"DataPlan\", \"DataUsage\", 'CustServCalls', 'DayMins', 'DayCalls', 'MonthlyCharge', 'OverageFee', 'RoamMins')\n", + "plt.figure(figsize=(60, 25))\n", + "data.hist()\n", + "plt.show()" ] }, { - "cell_type": "markdown", + "cell_type": "code", + "execution_count": 142, "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
ChurnAccountWeeksContractRenewalDataPlanDataUsageCustServCallsDayMinsDayCallsMonthlyChargeOverageFeeRoamMins
Churn1.0000000.016541-0.259852-0.102148-0.0871950.2087500.2051510.0184590.0723130.0928120.068239
AccountWeeks0.0165411.000000-0.0247350.0029180.014391-0.0037960.0062160.0384700.012581-0.0067490.009514
ContractRenewal-0.259852-0.0247351.000000-0.006006-0.0192230.024522-0.049396-0.003755-0.047291-0.019105-0.045871
DataPlan-0.1021480.002918-0.0060061.0000000.945982-0.017824-0.001684-0.0110860.7374900.021526-0.001318
DataUsage-0.0871950.014391-0.0192230.9459821.000000-0.0217230.003176-0.0079620.7816600.0196370.162746
CustServCalls0.208750-0.0037960.024522-0.017824-0.0217231.000000-0.013423-0.018942-0.028017-0.012964-0.009640
DayMins0.2051510.006216-0.049396-0.0016840.003176-0.0134231.0000000.0067500.5679680.007038-0.010155
DayCalls0.0184590.038470-0.003755-0.011086-0.007962-0.0189420.0067501.000000-0.007963-0.0214490.021565
MonthlyCharge0.0723130.012581-0.0472910.7374900.781660-0.0280170.567968-0.0079631.0000000.2817660.117433
OverageFee0.092812-0.006749-0.0191050.0215260.019637-0.0129640.007038-0.0214490.2817661.000000-0.011023
RoamMins0.0682390.009514-0.045871-0.0013180.162746-0.009640-0.0101550.0215650.117433-0.0110231.000000
\n", + "
" + ], + "text/plain": [ + " Churn AccountWeeks ContractRenewal DataPlan DataUsage \\\n", + "Churn 1.000000 0.016541 -0.259852 -0.102148 -0.087195 \n", + "AccountWeeks 0.016541 1.000000 -0.024735 0.002918 0.014391 \n", + "ContractRenewal -0.259852 -0.024735 1.000000 -0.006006 -0.019223 \n", + "DataPlan -0.102148 0.002918 -0.006006 1.000000 0.945982 \n", + "DataUsage -0.087195 0.014391 -0.019223 0.945982 1.000000 \n", + "CustServCalls 0.208750 -0.003796 0.024522 -0.017824 -0.021723 \n", + "DayMins 0.205151 0.006216 -0.049396 -0.001684 0.003176 \n", + "DayCalls 0.018459 0.038470 -0.003755 -0.011086 -0.007962 \n", + "MonthlyCharge 0.072313 0.012581 -0.047291 0.737490 0.781660 \n", + "OverageFee 0.092812 -0.006749 -0.019105 0.021526 0.019637 \n", + "RoamMins 0.068239 0.009514 -0.045871 -0.001318 0.162746 \n", + "\n", + " CustServCalls DayMins DayCalls MonthlyCharge OverageFee \\\n", + "Churn 0.208750 0.205151 0.018459 0.072313 0.092812 \n", + "AccountWeeks -0.003796 0.006216 0.038470 0.012581 -0.006749 \n", + "ContractRenewal 0.024522 -0.049396 -0.003755 -0.047291 -0.019105 \n", + "DataPlan -0.017824 -0.001684 -0.011086 0.737490 0.021526 \n", + "DataUsage -0.021723 0.003176 -0.007962 0.781660 0.019637 \n", + "CustServCalls 1.000000 -0.013423 -0.018942 -0.028017 -0.012964 \n", + "DayMins -0.013423 1.000000 0.006750 0.567968 0.007038 \n", + "DayCalls -0.018942 0.006750 1.000000 -0.007963 -0.021449 \n", + "MonthlyCharge -0.028017 0.567968 -0.007963 1.000000 0.281766 \n", + "OverageFee -0.012964 0.007038 -0.021449 0.281766 1.000000 \n", + "RoamMins -0.009640 -0.010155 0.021565 0.117433 -0.011023 \n", + "\n", + " RoamMins \n", + "Churn 0.068239 \n", + "AccountWeeks 0.009514 \n", + "ContractRenewal -0.045871 \n", + "DataPlan -0.001318 \n", + "DataUsage 0.162746 \n", + "CustServCalls -0.009640 \n", + "DayMins -0.010155 \n", + "DayCalls 0.021565 \n", + "MonthlyCharge 0.117433 \n", + "OverageFee -0.011023 \n", + "RoamMins 1.000000 " + ] + }, + "execution_count": 142, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ - "# Evaluation\n", - "\n", - "- Select the best performing model and write your comments about why choose this model.\n", - "- Analyse results and make comment about how you can improve model." + "data.corr()" ] + }, + { + "cell_type": "code", + "execution_count": 143, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 143, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "corr = data.corr()\n", + "sns.heatmap(corr)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": 144, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 144, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "data['AccountWeeks'].hist()" + ] + }, + { + "cell_type": "code", + "execution_count": 145, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
ChurnAccountWeeksContractRenewalDataPlanDataUsageCustServCallsDayMinsDayCallsMonthlyChargeOverageFeeRoamMins
Churn1.0000000.016541-0.259852-0.102148-0.0871950.2087500.2051510.0184590.0723130.0928120.068239
AccountWeeks0.0165411.000000-0.0247350.0029180.014391-0.0037960.0062160.0384700.012581-0.0067490.009514
ContractRenewal-0.259852-0.0247351.000000-0.006006-0.0192230.024522-0.049396-0.003755-0.047291-0.019105-0.045871
DataPlan-0.1021480.002918-0.0060061.0000000.945982-0.017824-0.001684-0.0110860.7374900.021526-0.001318
DataUsage-0.0871950.014391-0.0192230.9459821.000000-0.0217230.003176-0.0079620.7816600.0196370.162746
CustServCalls0.208750-0.0037960.024522-0.017824-0.0217231.000000-0.013423-0.018942-0.028017-0.012964-0.009640
DayMins0.2051510.006216-0.049396-0.0016840.003176-0.0134231.0000000.0067500.5679680.007038-0.010155
DayCalls0.0184590.038470-0.003755-0.011086-0.007962-0.0189420.0067501.000000-0.007963-0.0214490.021565
MonthlyCharge0.0723130.012581-0.0472910.7374900.781660-0.0280170.567968-0.0079631.0000000.2817660.117433
OverageFee0.092812-0.006749-0.0191050.0215260.019637-0.0129640.007038-0.0214490.2817661.000000-0.011023
RoamMins0.0682390.009514-0.045871-0.0013180.162746-0.009640-0.0101550.0215650.117433-0.0110231.000000
\n", + "
" + ], + "text/plain": [ + " Churn AccountWeeks ContractRenewal DataPlan DataUsage \\\n", + "Churn 1.000000 0.016541 -0.259852 -0.102148 -0.087195 \n", + "AccountWeeks 0.016541 1.000000 -0.024735 0.002918 0.014391 \n", + "ContractRenewal -0.259852 -0.024735 1.000000 -0.006006 -0.019223 \n", + "DataPlan -0.102148 0.002918 -0.006006 1.000000 0.945982 \n", + "DataUsage -0.087195 0.014391 -0.019223 0.945982 1.000000 \n", + "CustServCalls 0.208750 -0.003796 0.024522 -0.017824 -0.021723 \n", + "DayMins 0.205151 0.006216 -0.049396 -0.001684 0.003176 \n", + "DayCalls 0.018459 0.038470 -0.003755 -0.011086 -0.007962 \n", + "MonthlyCharge 0.072313 0.012581 -0.047291 0.737490 0.781660 \n", + "OverageFee 0.092812 -0.006749 -0.019105 0.021526 0.019637 \n", + "RoamMins 0.068239 0.009514 -0.045871 -0.001318 0.162746 \n", + "\n", + " CustServCalls DayMins DayCalls MonthlyCharge OverageFee \\\n", + "Churn 0.208750 0.205151 0.018459 0.072313 0.092812 \n", + "AccountWeeks -0.003796 0.006216 0.038470 0.012581 -0.006749 \n", + "ContractRenewal 0.024522 -0.049396 -0.003755 -0.047291 -0.019105 \n", + "DataPlan -0.017824 -0.001684 -0.011086 0.737490 0.021526 \n", + "DataUsage -0.021723 0.003176 -0.007962 0.781660 0.019637 \n", + "CustServCalls 1.000000 -0.013423 -0.018942 -0.028017 -0.012964 \n", + "DayMins -0.013423 1.000000 0.006750 0.567968 0.007038 \n", + "DayCalls -0.018942 0.006750 1.000000 -0.007963 -0.021449 \n", + "MonthlyCharge -0.028017 0.567968 -0.007963 1.000000 0.281766 \n", + "OverageFee -0.012964 0.007038 -0.021449 0.281766 1.000000 \n", + "RoamMins -0.009640 -0.010155 0.021565 0.117433 -0.011023 \n", + "\n", + " RoamMins \n", + "Churn 0.068239 \n", + "AccountWeeks 0.009514 \n", + "ContractRenewal -0.045871 \n", + "DataPlan -0.001318 \n", + "DataUsage 0.162746 \n", + "CustServCalls -0.009640 \n", + "DayMins -0.010155 \n", + "DayCalls 0.021565 \n", + "MonthlyCharge 0.117433 \n", + "OverageFee -0.011023 \n", + "RoamMins 1.000000 " + ] + }, + "execution_count": 145, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "data.corr()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Preprocessing\n", + "\n", + "- Are there any duplicated values?\n", + "- Do we need to do feature scaling?\n", + "- Do we need to generate new features?\n", + "- Split Train and Test dataset. (0.7/0.3)" + ] + }, + { + "cell_type": "code", + "execution_count": 147, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "0 2850\n", + "1 483\n", + "Name: Churn, dtype: int64" + ] + }, + "execution_count": 147, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "data[\"Churn\"].value_counts()" + ] + }, + { + "cell_type": "code", + "execution_count": 148, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[0.41167182, 0.67648946, 0.32758048, ..., 1.99072703, 0.0715836 ,\n", + " 0.08500823],\n", + " [0.41167182, 0.14906505, 0.32758048, ..., 1.56451025, 0.10708191,\n", + " 1.24048169],\n", + " [0.41167182, 0.9025285 , 0.32758048, ..., 0.26213309, 1.57434567,\n", + " 0.70312091],\n", + " ...,\n", + " [0.41167182, 1.83505538, 0.32758048, ..., 0.01858065, 1.73094204,\n", + " 1.3837779 ],\n", + " [0.41167182, 2.08295458, 3.05268496, ..., 0.38390932, 0.81704825,\n", + " 1.87621082],\n", + " [0.41167182, 0.67974475, 0.32758048, ..., 2.66049626, 1.28129669,\n", + " 1.24048169]])" + ] + }, + "execution_count": 148, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from scipy import stats\n", + "import numpy as np\n", + "z = np.abs(stats.zscore(data))\n", + "z" + ] + }, + { + "cell_type": "code", + "execution_count": 149, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "414" + ] + }, + "execution_count": 149, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "outliers = list(set(np.where(z > 3)[0]))\n", + "\n", + "len(outliers)" + ] + }, + { + "cell_type": "code", + "execution_count": 152, + "metadata": {}, + "outputs": [], + "source": [ + "from sklearn.linear_model import LogisticRegression\n", + "from sklearn.metrics import classification_report, confusion_matrix\n", + "from sklearn.model_selection import train_test_split, cross_validate" + ] + }, + { + "cell_type": "code", + "execution_count": 154, + "metadata": {}, + "outputs": [], + "source": [ + "y = data.Churn" + ] + }, + { + "cell_type": "code", + "execution_count": 155, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "0 0\n", + "1 0\n", + "2 0\n", + "3 0\n", + "4 0\n", + " ..\n", + "3328 0\n", + "3329 0\n", + "3330 0\n", + "3331 0\n", + "3332 0\n", + "Name: Churn, Length: 3333, dtype: int64" + ] + }, + "execution_count": 155, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "y" + ] + }, + { + "cell_type": "code", + "execution_count": 157, + "metadata": {}, + "outputs": [], + "source": [ + "X=data.drop('Churn',axis=1)" + ] + }, + { + "cell_type": "code", + "execution_count": 159, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
AccountWeeksContractRenewalDataPlanDataUsageCustServCallsDayMinsDayCallsMonthlyChargeOverageFeeRoamMins
0128112.701265.111089.09.8710.0
1107113.701161.612382.09.7813.7
2137100.000243.411452.06.0612.2
384000.002299.47157.03.106.6
475000.003166.711341.07.4210.1
.................................
3328192112.672156.27771.710.789.9
332968100.343231.15756.47.679.6
333028100.002180.810956.014.4414.1
3331184000.002213.810550.07.985.0
333274113.700234.4113100.013.3013.7
\n", + "

3333 rows × 10 columns

\n", + "
" + ], + "text/plain": [ + " AccountWeeks ContractRenewal DataPlan DataUsage CustServCalls \\\n", + "0 128 1 1 2.70 1 \n", + "1 107 1 1 3.70 1 \n", + "2 137 1 0 0.00 0 \n", + "3 84 0 0 0.00 2 \n", + "4 75 0 0 0.00 3 \n", + "... ... ... ... ... ... \n", + "3328 192 1 1 2.67 2 \n", + "3329 68 1 0 0.34 3 \n", + "3330 28 1 0 0.00 2 \n", + "3331 184 0 0 0.00 2 \n", + "3332 74 1 1 3.70 0 \n", + "\n", + " DayMins DayCalls MonthlyCharge OverageFee RoamMins \n", + "0 265.1 110 89.0 9.87 10.0 \n", + "1 161.6 123 82.0 9.78 13.7 \n", + "2 243.4 114 52.0 6.06 12.2 \n", + "3 299.4 71 57.0 3.10 6.6 \n", + "4 166.7 113 41.0 7.42 10.1 \n", + "... ... ... ... ... ... \n", + "3328 156.2 77 71.7 10.78 9.9 \n", + "3329 231.1 57 56.4 7.67 9.6 \n", + "3330 180.8 109 56.0 14.44 14.1 \n", + "3331 213.8 105 50.0 7.98 5.0 \n", + "3332 234.4 113 100.0 13.30 13.7 \n", + "\n", + "[3333 rows x 10 columns]" + ] + }, + "execution_count": 159, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "X" + ] + }, + { + "cell_type": "code", + "execution_count": 161, + "metadata": {}, + "outputs": [], + "source": [ + "X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)" + ] + }, + { + "cell_type": "code", + "execution_count": 163, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
indexChurnAccountWeeksContractRenewalDataPlanDataUsageCustServCallsDayMinsDayCallsMonthlyChargeOverageFeeRoamMins
000128112.701265.111089.09.8710.0
110107113.701161.612382.09.7813.7
220137100.000243.411452.06.0612.2
360121112.033218.28887.317.437.5
480117100.191184.59763.917.588.7
.......................................
29143327079100.002134.79840.09.4911.8
291533280192112.672156.27771.710.789.9
29163329068100.343231.15756.47.679.6
29173330028100.002180.810956.014.4414.1
29183332074113.700234.4113100.013.3013.7
\n", + "

2919 rows × 12 columns

\n", + "
" + ], + "text/plain": [ + " index Churn AccountWeeks ContractRenewal DataPlan DataUsage \\\n", + "0 0 0 128 1 1 2.70 \n", + "1 1 0 107 1 1 3.70 \n", + "2 2 0 137 1 0 0.00 \n", + "3 6 0 121 1 1 2.03 \n", + "4 8 0 117 1 0 0.19 \n", + "... ... ... ... ... ... ... \n", + "2914 3327 0 79 1 0 0.00 \n", + "2915 3328 0 192 1 1 2.67 \n", + "2916 3329 0 68 1 0 0.34 \n", + "2917 3330 0 28 1 0 0.00 \n", + "2918 3332 0 74 1 1 3.70 \n", + "\n", + " CustServCalls DayMins DayCalls MonthlyCharge OverageFee RoamMins \n", + "0 1 265.1 110 89.0 9.87 10.0 \n", + "1 1 161.6 123 82.0 9.78 13.7 \n", + "2 0 243.4 114 52.0 6.06 12.2 \n", + "3 3 218.2 88 87.3 17.43 7.5 \n", + "4 1 184.5 97 63.9 17.58 8.7 \n", + "... ... ... ... ... ... ... \n", + "2914 2 134.7 98 40.0 9.49 11.8 \n", + "2915 2 156.2 77 71.7 10.78 9.9 \n", + "2916 3 231.1 57 56.4 7.67 9.6 \n", + "2917 2 180.8 109 56.0 14.44 14.1 \n", + "2918 0 234.4 113 100.0 13.30 13.7 \n", + "\n", + "[2919 rows x 12 columns]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/plain": [ + "2919" + ] + }, + "execution_count": 163, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "\n", + "new_df = data.drop(outliers,axis = 0).reset_index(drop = False)\n", + "display(new_df)\n", + "\n", + "y_new = y[list(new_df[\"index\"])]\n", + "len(y_new)" + ] + }, + { + "cell_type": "code", + "execution_count": 164, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[-0.35150616, 0.69196206, 0. , ..., 2.05929645,\n", + " -0.068431 , -0.0941079 ],\n", + " [-0.35150616, 0.1624696 , 0. , ..., 1.62161451,\n", + " -0.10450144, 1.29308134],\n", + " [-0.35150616, 0.9188874 , 0. , ..., -0.25416527,\n", + " -1.59541298, 0.73070732],\n", + " ...,\n", + " [-0.35150616, -0.82087355, 0. , ..., 0.0209491 ,\n", + " -0.95015288, -0.2440743 ],\n", + " [-0.35150616, -1.82943062, 0. , ..., -0.0040613 ,\n", + " 1.76314581, 1.44304774],\n", + " [-0.35150616, -0.66958999, 0. , ..., 2.74708237,\n", + " 1.30625356, 1.29308134]])" + ] + }, + "execution_count": 164, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "X_new = new_df.drop('index', axis = 1)\n", + "\n", + "X_scaled = StandardScaler().fit_transform(X_new)\n", + "X_scaled" + ] + }, + { + "cell_type": "code", + "execution_count": 71, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[-0.35150616, 0.69196206, 0. , ..., 2.05929645,\n", + " -0.068431 , -0.0941079 ],\n", + " [-0.35150616, 0.1624696 , 0. , ..., 1.62161451,\n", + " -0.10450144, 1.29308134],\n", + " [-0.35150616, 0.9188874 , 0. , ..., -0.25416527,\n", + " -1.59541298, 0.73070732],\n", + " ...,\n", + " [-0.35150616, -0.82087355, 0. , ..., 0.0209491 ,\n", + " -0.95015288, -0.2440743 ],\n", + " [-0.35150616, -1.82943062, 0. , ..., -0.0040613 ,\n", + " 1.76314581, 1.44304774],\n", + " [-0.35150616, -0.66958999, 0. , ..., 2.74708237,\n", + " 1.30625356, 1.29308134]])" + ] + }, + "execution_count": 71, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "data = new_data.drop('index', axis = 1)\n", + "\n", + "data = StandardScaler().fit_transform(data)\n", + "data" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# ML Application\n", + "\n", + "- Define models.\n", + "- Fit models.\n", + "- Evaluate models for both train and test dataset.\n", + "- Generate Confusion Matrix and scores of Accuracy, Recall, Precision and F1-Score.\n", + "- Analyse occurrence of overfitting and underfitting. If there is any of them, try to overcome it within a different section." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Logistic Regression" + ] + }, + { + "cell_type": "code", + "execution_count": 166, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Mean training accuracy: 0.8551219232453166\n", + "Test accuracy: 0.848\n" + ] + } + ], + "source": [ + "models = LogisticRegression(random_state=42, n_jobs=-1)\n", + "cv = cross_validate(models,X_train,y_train,cv = 3, n_jobs=-1, return_estimator=True)\n", + "\n", + "print(\"Mean training accuracy: {}\".format(np.mean(cv['test_score'])))\n", + "print(\"Test accuracy: {}\".format(cv[\"estimator\"][0].score(X_test,y_test)))" + ] + }, + { + "cell_type": "code", + "execution_count": 209, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[830, 27],\n", + " [125, 18]], dtype=int64)" + ] + }, + "execution_count": 209, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "pred_prob1 = cv[\"estimator\"][0].predict(X_test)\n", + "\n", + "cm = confusion_matrix(y_test, pred_prob1)\n", + "cm" + ] + }, + { + "cell_type": "code", + "execution_count": 210, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plt.figure(figsize=(12, 8))\n", + "ax =sns.heatmap(cm, square=True, annot=True, cbar=False)\n", + "ax.xaxis.set_ticklabels([\"False\",\"True\"], fontsize = 12)\n", + "ax.yaxis.set_ticklabels([\"False\",\"True\"], fontsize = 12, rotation=0)\n", + "ax.set_xlabel('Predicted Labels',fontsize = 15)\n", + "ax.set_ylabel('True Labels',fontsize = 15)\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 211, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " precision recall f1-score support\n", + "\n", + " 0 0.87 0.97 0.92 857\n", + " 1 0.40 0.13 0.19 143\n", + "\n", + " accuracy 0.85 1000\n", + " macro avg 0.63 0.55 0.55 1000\n", + "weighted avg 0.80 0.85 0.81 1000\n", + "\n" + ] + } + ], + "source": [ + "print(classification_report(y_test,pred_prob1))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Decision Tree" + ] + }, + { + "cell_type": "code", + "execution_count": 181, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Accuracy of train: 0.9309901414487785\n", + "Accuracy of test: 0.92\n" + ] + } + ], + "source": [ + "clf = DecisionTreeClassifier(max_depth=4 , random_state=42)\n", + "clf.fit(X_train,y_train)\n", + "print(\"Accuracy of train:\",clf.score(X_train,y_train))\n", + "print(\"Accuracy of test:\",clf.score(X_test,y_test))" + ] + }, + { + "cell_type": "code", + "execution_count": 212, + "metadata": {}, + "outputs": [], + "source": [ + "pred_prob2 = clf.predict(X_test)" + ] + }, + { + "cell_type": "code", + "execution_count": 214, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " precision recall f1-score support\n", + "\n", + " 0 0.86 1.00 0.92 857\n", + " 1 1.00 0.01 0.01 143\n", + "\n", + " accuracy 0.86 1000\n", + " macro avg 0.93 0.50 0.47 1000\n", + "weighted avg 0.88 0.86 0.79 1000\n", + "\n" + ] + } + ], + "source": [ + "print(classification_report(y_test,pred_prob2))" + ] + }, + { + "cell_type": "code", + "execution_count": 218, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[857, 0],\n", + " [142, 1]], dtype=int64)" + ] + }, + "execution_count": 218, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "cm = confusion_matrix(y_test, pred_prob2)\n", + "cm" + ] + }, + { + "cell_type": "code", + "execution_count": 219, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plt.figure(figsize=(12, 8))\n", + "ax =sns.heatmap(cm, square=True, annot=True, cbar=False)\n", + "ax.xaxis.set_ticklabels([\"False\",\"True\"], fontsize = 12)\n", + "ax.yaxis.set_ticklabels([\"False\",\"True\"], fontsize = 12, rotation=0)\n", + "ax.set_xlabel('Predicted Labels',fontsize = 15)\n", + "ax.set_ylabel('True Labels',fontsize = 15)\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### SVM - Support Vector Machine" + ] + }, + { + "cell_type": "code", + "execution_count": 232, + "metadata": {}, + "outputs": [], + "source": [ + "clf_svm = svm.SVC(random_state=24)" + ] + }, + { + "cell_type": "code", + "execution_count": 235, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Accuracy of train: 0.8551221603086155\n", + "Accuracy of test: 0.858\n" + ] + } + ], + "source": [ + "clf_svm.fit(X_train,y_train)\n", + "print(\"Accuracy of train:\",clf.score(X_train,y_train))\n", + "print(\"Accuracy of test:\",clf.score(X_test,y_test))" + ] + }, + { + "cell_type": "code", + "execution_count": 239, + "metadata": {}, + "outputs": [], + "source": [ + "pred_prob3 = clf_svm.predict(X_test)" + ] + }, + { + "cell_type": "code", + "execution_count": 240, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[857, 0],\n", + " [142, 1]], dtype=int64)" + ] + }, + "execution_count": 240, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "cm = confusion_matrix(y_test, pred_prob3)\n", + "cm" + ] + }, + { + "cell_type": "code", + "execution_count": 241, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " precision recall f1-score support\n", + "\n", + " 0 0.86 1.00 0.92 857\n", + " 1 1.00 0.01 0.01 143\n", + "\n", + " accuracy 0.86 1000\n", + " macro avg 0.93 0.50 0.47 1000\n", + "weighted avg 0.88 0.86 0.79 1000\n", + "\n" + ] + } + ], + "source": [ + "print(classification_report(y_test,pred_prob3))" + ] + }, + { + "cell_type": "code", + "execution_count": 204, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plt.figure(figsize=(12, 8))\n", + "ax =sns.heatmap(cm, square=True, annot=True, cbar=False)\n", + "ax.xaxis.set_ticklabels([\"False\",\"True\"], fontsize = 12)\n", + "ax.yaxis.set_ticklabels([\"False\",\"True\"], fontsize = 12, rotation=0)\n", + "ax.set_xlabel('Predicted Labels',fontsize = 15)\n", + "ax.set_ylabel('True Labels',fontsize = 15)\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Evaluation\n", + "\n", + "- Select the best performing model and write your comments about why choose this model.\n", + "- Analyse results and make comment about how you can improve model." + ] + }, + { + "cell_type": "code", + "execution_count": 244, + "metadata": {}, + "outputs": [ + { + "ename": "IndexError", + "evalue": "too many indices for array: array is 1-dimensional, but 2 were indexed", + "output_type": "error", + "traceback": [ + "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[1;31mIndexError\u001b[0m Traceback (most recent call last)", + "\u001b[1;32m\u001b[0m in \u001b[0;36m\u001b[1;34m\u001b[0m\n\u001b[0;32m 2\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 3\u001b[0m \u001b[1;31m# roc curve for models\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 4\u001b[1;33m \u001b[0mfpr1\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mtpr1\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mthresh1\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mroc_curve\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0my_test\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mpred_prob1\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;36m1\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mpos_label\u001b[0m\u001b[1;33m=\u001b[0m\u001b[1;36m1\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m 5\u001b[0m \u001b[0mfpr2\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mtpr2\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mthresh2\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mroc_curve\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0my_test\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mpred_prob2\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;36m1\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mpos_label\u001b[0m\u001b[1;33m=\u001b[0m\u001b[1;36m2\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 6\u001b[0m \u001b[0mfpr3\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mtpr3\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mthresh3\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mroc_curve\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0my_test\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mpred_prob3\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;36m1\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mpos_label\u001b[0m\u001b[1;33m=\u001b[0m\u001b[1;36m3\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", + "\u001b[1;31mIndexError\u001b[0m: too many indices for array: array is 1-dimensional, but 2 were indexed" + ] + } + ], + "source": [ + "from sklearn.metrics import roc_curve\n", + "\n", + "# roc curve for models\n", + "fpr1, tpr1, thresh1 = roc_curve(y_test, pred_prob1[:,1], pos_label=1)\n", + "fpr2, tpr2, thresh2 = roc_curve(y_test, pred_prob2[:,1], pos_label=1)\n", + "fpr3, tpr3, thresh3 = roc_curve(y_test, pred_prob3[:,1], pos_label=1)\n", + "\n", + "# roc curve for tpr = fpr \n", + "random_probs = [0 for i in range(len(y_test))]\n", + "p_fpr, p_tpr, _ = roc_curve(y_test, random_probs, pos_label=1)\n", + "\n", + "\n", + "\n", + "from sklearn.metrics import roc_auc_score\n", + "\n", + "# auc scores\n", + "auc_score1 = roc_auc_score(y_test, pred_prob1[:,1])\n", + "auc_score2 = roc_auc_score(y_test, pred_prob2[:,1])\n", + "auc_score3 = roc_auc_score(y_test, pred_prob3[:,1])\n", + "\n", + "print(auc_score1, auc_score2, auc_score3)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] } ], "metadata": { @@ -323,7 +2327,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.7.3" + "version": "3.7.9" } }, "nbformat": 4, diff --git a/Regularization/.ipynb_checkpoints/regularization-checkpoint.ipynb b/Regularization/.ipynb_checkpoints/regularization-checkpoint.ipynb new file mode 100644 index 0000000..7b59912 --- /dev/null +++ b/Regularization/.ipynb_checkpoints/regularization-checkpoint.ipynb @@ -0,0 +1,1307 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + " \"Open\n", + "" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "colab_type": "text", + "id": "eGMjJYeplnfS" + }, + "source": [ + " All rights reserved © Global AI Hub 2020 \n", + " \n", + "\n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "colab_type": "text", + "id": "20RFH5fJlmoU" + }, + "source": [ + "# Regularization" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "colab_type": "text", + "id": "NhnitxlJlmoW" + }, + "source": [ + "## What is Regularization?" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "![](img/1.png)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "colab_type": "text", + "id": "L-et45HalmoY" + }, + "source": [ + "As we move towards the right in this image, our model tries to learn too well the details and the noise from the training data, which ultimately results in poor performance on the unseen data." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "colab_type": "text", + "id": "Cj-EgOdTlmoZ" + }, + "source": [ + "In other words, while going towards the right, the complexity of the model increases such that the training error reduces but the testing error doesn’t. This is shown in the image below." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "colab_type": "text", + "id": "XTxBAXp9lmoa" + }, + "source": [ + "![](img/2.png)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "colab_type": "text", + "id": "_fbx2bb-lmob" + }, + "source": [ + "Regularization is a technique which makes slight modifications to the learning algorithm such that the model generalizes better. This in turn improves the model’s performance on the unseen data as well." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "colab_type": "text", + "id": "ZoBOI3x8lmod" + }, + "source": [ + "## Underfitting and Overfitting" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "colab_type": "text", + "id": "RXHl79wolmoe" + }, + "source": [ + "Before diving further let’s understand the important terms:\n", + "\n", + "Bias – Assumptions made by a model to make a function easier to learn.\n", + "\n", + "Variance – If you train your data on training data and obtain a very low error, upon changing the data and then training the same previous model you experience high error, this is variance." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "colab_type": "text", + "id": "H5FVNnzhlmof" + }, + "source": [ + "#### Underfitting" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "colab_type": "text", + "id": "0dJ-prYHlmog" + }, + "source": [ + "A statistical model or a machine learning algorithm is said to have underfitting when it cannot capture the underlying trend of the data. Underfitting destroys the accuracy of our machine learning model. Its occurrence simply means that our model or the algorithm does not fit the data well enough. It usually happens when we have less data to build an accurate model and also when we try to build a linear model with a non-linear data. In such cases the rules of the machine learning model are too easy and flexible to be applied on such minimal data and therefore the model will probably make a lot of wrong predictions. Underfitting can be avoided by using more data and also reducing the features by feature selection.\n", + "\n", + "Underfitting – High bias and low variance\n", + "\n", + "Techniques to reduce underfitting :\n", + "1. Increase model complexity\n", + "2. Increase number of features, performing feature engineering\n", + "3. Remove noise from the data.\n", + "4. Increase the number of epochs or increase the duration of training to get better results." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "colab_type": "text", + "id": "D0Z1D2C3lmoj" + }, + "source": [ + "#### Overfitting" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "colab_type": "text", + "id": "c06krbaqlmol" + }, + "source": [ + "A statistical model is said to be overfitted, when we train it with a lot of data. When a model gets trained with so much of data, it starts learning from the noise and inaccurate data entries in our data set. Then the model does not categorize the data correctly, because of too many details and noise. The causes of overfitting are the non-parametric and non-linear methods because these types of machine learning algorithms have more freedom in building the model based on the dataset and therefore they can really build unrealistic models. A solution to avoid overfitting is using a linear algorithm if we have linear data or using the parameters like the maximal depth if we are using decision trees.\n", + "\n", + "Overfitting – High variance and low bias\n", + "\n", + "Techniques to reduce overfitting :\n", + "1. Increase training data.\n", + "2. Reduce model complexity.\n", + "3. Early stopping during the training phase (have an eye over the loss over the training period as soon as loss begins to increase stop training).\n", + "4. Ridge Regularization and Lasso Regularization\n", + "5. Use dropout for neural networks to tackle overfitting." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "colab_type": "text", + "id": "sZUR9dp2lmom" + }, + "source": [ + "\n", + "" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "colab_type": "text", + "id": "qKBncR2llmop" + }, + "source": [ + "### Ridge Regression" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "colab_type": "text", + "id": "FYymr4AOlmoq" + }, + "source": [ + "Ridge regression is also called L2 regularization. It adds a constraint that is a linear function of the squared coefficients." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "colab_type": "text", + "id": "5xo2joEXlmos" + }, + "source": [ + "\n", + "" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "colab_type": "text", + "id": "CEveA8_8lmot" + }, + "source": [ + "To minimize the regularized loss function, we need to choose λ to minimize the sum of the area of the circle and the area of the ellipsoid chosen by the tangency.\n", + "\n", + "Note that when λ tends to zero, the regularized loss function becomes the OLS loss function.\n", + "\n", + "When λ tends to infinity, we get an intercept-only model (because in this case, the ridge regression coefficients tend to zero). Now we have smaller variance but larger bias.\n", + "\n", + "A critique of ridge regression is that all the variables tend to end up in the model. The model only shrinks the coefficients." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "colab_type": "text", + "id": "D1rYoxO7lmou" + }, + "source": [ + "### Lasso " + ] + }, + { + "cell_type": "markdown", + "metadata": { + "colab_type": "text", + "id": "Z50XcFW7lmov" + }, + "source": [ + "Lasso is also known as L1 regularization. It penalizes the model by the absolute weight coefficients." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "colab_type": "text", + "id": "Y6T9pjK7lmox" + }, + "source": [ + "" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "colab_type": "text", + "id": "RXBwjdnKlmoz" + }, + "source": [ + "Lasso works in the following way: it forces the sum of the absolute value of the coefficients to be less than a constant, which forces some of the coefficients to be zero and results in a simpler model. This is because comparing to the L2 regularization, the ellipsoid has the tendency to touch the diamond-shaped constraint on the corner.\n", + "\n", + "Lasso performs better than ridge regression in the sense that it helps a lot with feature selection." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "colab": {}, + "colab_type": "code", + "id": "Q2Uf_S23lmo6" + }, + "outputs": [], + "source": [ + "# Import packages and observe dataset" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "colab": {}, + "colab_type": "code", + "id": "AryxEyFAlmpA" + }, + "outputs": [], + "source": [ + "#Import numerical libraries\n", + "import pandas as pd\n", + "import numpy as np\n", + "\n", + "#Import graphical plotting libraries\n", + "import seaborn as sns\n", + "import matplotlib.pyplot as plt\n", + "%matplotlib inline\n", + "\n", + "#Import Linear Regression Machine Learning Libraries\n", + "from sklearn import preprocessing\n", + "from sklearn.model_selection import train_test_split\n", + "\n", + "from sklearn.linear_model import LinearRegression, Ridge, Lasso\n", + "from sklearn.metrics import r2_score" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": { + "colab": {}, + "colab_type": "code", + "id": "OMmycw9glmpE", + "outputId": "678dea27-1b77-4ed8-a15a-00099d94ec03" + }, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
mpgcylindersdisplacementhorsepowerweightaccelerationmodel_yearoriginname
018.08307.0130350412.0701chevrolet chevelle malibu
115.08350.0165369311.5701buick skylark 320
218.08318.0150343611.0701plymouth satellite
316.08304.0150343312.0701amc rebel sst
417.08302.0140344910.5701ford torino
\n", + "
" + ], + "text/plain": [ + " mpg cylinders displacement horsepower weight acceleration model_year \\\n", + "0 18.0 8 307.0 130 3504 12.0 70 \n", + "1 15.0 8 350.0 165 3693 11.5 70 \n", + "2 18.0 8 318.0 150 3436 11.0 70 \n", + "3 16.0 8 304.0 150 3433 12.0 70 \n", + "4 17.0 8 302.0 140 3449 10.5 70 \n", + "\n", + " origin name \n", + "0 1 chevrolet chevelle malibu \n", + "1 1 buick skylark 320 \n", + "2 1 plymouth satellite \n", + "3 1 amc rebel sst \n", + "4 1 ford torino " + ] + }, + "execution_count": 2, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "data_raw = pd.read_csv('datasets/reg.csv')\n", + "data_raw.head()" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "RangeIndex: 398 entries, 0 to 397\n", + "Data columns (total 9 columns):\n", + " # Column Non-Null Count Dtype \n", + "--- ------ -------------- ----- \n", + " 0 mpg 398 non-null float64\n", + " 1 cylinders 398 non-null int64 \n", + " 2 displacement 398 non-null float64\n", + " 3 horsepower 398 non-null object \n", + " 4 weight 398 non-null int64 \n", + " 5 acceleration 398 non-null float64\n", + " 6 model_year 398 non-null int64 \n", + " 7 origin 398 non-null int64 \n", + " 8 name 398 non-null object \n", + "dtypes: float64(3), int64(4), object(2)\n", + "memory usage: 28.1+ KB\n" + ] + } + ], + "source": [ + "data_raw.info()" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": { + "colab": {}, + "colab_type": "code", + "id": "82mm8sMrlmpJ" + }, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
mpgcylindersdisplacementhorsepowerweightaccelerationmodel_yearorigin
018.08307.0130350412.0701
115.08350.0165369311.5701
218.08318.0150343611.0701
316.08304.0150343312.0701
417.08302.0140344910.5701
\n", + "
" + ], + "text/plain": [ + " mpg cylinders displacement horsepower weight acceleration model_year \\\n", + "0 18.0 8 307.0 130 3504 12.0 70 \n", + "1 15.0 8 350.0 165 3693 11.5 70 \n", + "2 18.0 8 318.0 150 3436 11.0 70 \n", + "3 16.0 8 304.0 150 3433 12.0 70 \n", + "4 17.0 8 302.0 140 3449 10.5 70 \n", + "\n", + " origin \n", + "0 1 \n", + "1 1 \n", + "2 1 \n", + "3 1 \n", + "4 1 " + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "#Drop car name\n", + "#Replace origin into 1,2,3.. dont forget get_dummies\n", + "#Replace ? with nan\n", + "#Replace all nan with median\n", + "\n", + "data = data_raw.drop(['name'], axis = 1)\n", + "data.head()" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "mpg 0\n", + "cylinders 0\n", + "displacement 0\n", + "horsepower 0\n", + "weight 0\n", + "acceleration 0\n", + "model_year 0\n", + "origin 0\n", + "dtype: int64" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "data.isna().sum()" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "mpg 0\n", + "cylinders 0\n", + "displacement 0\n", + "horsepower 6\n", + "weight 0\n", + "acceleration 0\n", + "model_year 0\n", + "origin 0\n", + "dtype: int64" + ] + }, + "execution_count": 11, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "data.isin(['?']).sum()" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
mpgcylindersdisplacementhorsepowerweightaccelerationmodel_yearorigin_americaorigin_asiaorigin_europe
018.08307.0130350412.070100
115.08350.0165369311.570100
218.08318.0150343611.070100
316.08304.0150343312.070100
417.08302.0140344910.570100
\n", + "
" + ], + "text/plain": [ + " mpg cylinders displacement horsepower weight acceleration model_year \\\n", + "0 18.0 8 307.0 130 3504 12.0 70 \n", + "1 15.0 8 350.0 165 3693 11.5 70 \n", + "2 18.0 8 318.0 150 3436 11.0 70 \n", + "3 16.0 8 304.0 150 3433 12.0 70 \n", + "4 17.0 8 302.0 140 3449 10.5 70 \n", + "\n", + " origin_america origin_asia origin_europe \n", + "0 1 0 0 \n", + "1 1 0 0 \n", + "2 1 0 0 \n", + "3 1 0 0 \n", + "4 1 0 0 " + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "data['origin'] = data['origin'].replace({1: 'america', 2: 'europe', 3: 'asia'})\n", + "data = pd.get_dummies(data, columns = ['origin'])\n", + "data = data.replace('?', np.nan)\n", + "data = data.apply(lambda x: x.fillna(x.median()), axis = 0)\n", + "data.head()" + ] + }, + { + "cell_type": "code", + "execution_count": 143, + "metadata": { + "colab": {}, + "colab_type": "code", + "id": "PEzoE7HLlmpR" + }, + "outputs": [], + "source": [ + "# Model building" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": { + "colab": {}, + "colab_type": "code", + "id": "WnV4zqeQlmpW" + }, + "outputs": [], + "source": [ + "X = data.drop(['mpg'], axis = 1) # independent variable\n", + "y = data[['mpg']] #dependent variable" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": { + "colab": {}, + "colab_type": "code", + "id": "JxfdOeeOlmpa", + "outputId": "03846650-c3b3-4736-f4b9-234237103363" + }, + "outputs": [], + "source": [ + "#Scaling the data\n", + "\n", + "X_s = preprocessing.scale(X)\n", + "X_s = pd.DataFrame(X_s, columns = X.columns) #converting scaled data into dataframe\n", + "\n", + "y_s = preprocessing.scale(y)\n", + "y_s = pd.DataFrame(y_s, columns = y.columns) #ideally train, test data should be in columns" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
cylindersdisplacementhorsepowerweightaccelerationmodel_yearorigin_americaorigin_asiaorigin_europe
01.4981911.0906040.6731180.630870-1.295498-1.6274260.773559-0.497643-0.461968
11.4981911.5035141.5899580.854333-1.477038-1.6274260.773559-0.497643-0.461968
21.4981911.1962321.1970270.550470-1.658577-1.6274260.773559-0.497643-0.461968
31.4981911.0617961.1970270.546923-1.295498-1.6274260.773559-0.497643-0.461968
41.4981911.0425910.9350720.565841-1.840117-1.6274260.773559-0.497643-0.461968
..............................
393-0.856321-0.513026-0.479482-0.2133240.0115861.6219830.773559-0.497643-0.461968
394-0.856321-0.925936-1.370127-0.9936713.2792961.621983-1.292726-0.4976432.164651
395-0.856321-0.561039-0.531873-0.798585-1.4407301.6219830.773559-0.497643-0.461968
396-0.856321-0.705077-0.662850-0.4084111.1008221.6219830.773559-0.497643-0.461968
397-0.856321-0.714680-0.584264-0.2960881.3912851.6219830.773559-0.497643-0.461968
\n", + "

398 rows × 9 columns

\n", + "
" + ], + "text/plain": [ + " cylinders displacement horsepower weight acceleration model_year \\\n", + "0 1.498191 1.090604 0.673118 0.630870 -1.295498 -1.627426 \n", + "1 1.498191 1.503514 1.589958 0.854333 -1.477038 -1.627426 \n", + "2 1.498191 1.196232 1.197027 0.550470 -1.658577 -1.627426 \n", + "3 1.498191 1.061796 1.197027 0.546923 -1.295498 -1.627426 \n", + "4 1.498191 1.042591 0.935072 0.565841 -1.840117 -1.627426 \n", + ".. ... ... ... ... ... ... \n", + "393 -0.856321 -0.513026 -0.479482 -0.213324 0.011586 1.621983 \n", + "394 -0.856321 -0.925936 -1.370127 -0.993671 3.279296 1.621983 \n", + "395 -0.856321 -0.561039 -0.531873 -0.798585 -1.440730 1.621983 \n", + "396 -0.856321 -0.705077 -0.662850 -0.408411 1.100822 1.621983 \n", + "397 -0.856321 -0.714680 -0.584264 -0.296088 1.391285 1.621983 \n", + "\n", + " origin_america origin_asia origin_europe \n", + "0 0.773559 -0.497643 -0.461968 \n", + "1 0.773559 -0.497643 -0.461968 \n", + "2 0.773559 -0.497643 -0.461968 \n", + "3 0.773559 -0.497643 -0.461968 \n", + "4 0.773559 -0.497643 -0.461968 \n", + ".. ... ... ... \n", + "393 0.773559 -0.497643 -0.461968 \n", + "394 -1.292726 -0.497643 2.164651 \n", + "395 0.773559 -0.497643 -0.461968 \n", + "396 0.773559 -0.497643 -0.461968 \n", + "397 0.773559 -0.497643 -0.461968 \n", + "\n", + "[398 rows x 9 columns]" + ] + }, + "execution_count": 10, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "X_s" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": { + "colab": {}, + "colab_type": "code", + "id": "8P5JzDBMlmpe", + "outputId": "ed4436cb-8aa2-4d85-fc94-9ff4cf61378b" + }, + "outputs": [ + { + "data": { + "text/plain": [ + "(278, 9)" + ] + }, + "execution_count": 11, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "#Split into train, test set\n", + "\n", + "X_train, X_test, y_train,y_test = train_test_split(X_s, y_s, test_size = 0.30, random_state = 102)\n", + "X_train.shape" + ] + }, + { + "cell_type": "code", + "execution_count": 147, + "metadata": { + "colab": {}, + "colab_type": "code", + "id": "QuEtPChAlmph" + }, + "outputs": [], + "source": [ + "# Simple Linear Model" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": { + "colab": {}, + "colab_type": "code", + "id": "6oJNDtoIlmpl", + "outputId": "857b5f78-64fe-4263-bd4f-fb0c1488177f" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Regression model coef: [[ 0.00786436 0.21673705 -0.11482021 -0.64460528 0.02689514 0.3781176\n", + " -0.12143029 0.10030822 0.04927016]]\n" + ] + } + ], + "source": [ + "#Fit simple linear model and find coefficients\n", + "regression_model = LinearRegression()\n", + "regression_model.fit(X_train, y_train)\n", + "\n", + "print(f'Regression model coef: {regression_model.coef_}')\n" + ] + }, + { + "cell_type": "code", + "execution_count": 149, + "metadata": { + "colab": {}, + "colab_type": "code", + "id": "xquEQhq9lmpo" + }, + "outputs": [], + "source": [ + "# Regularized Ridge Regression" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": { + "colab": {}, + "colab_type": "code", + "id": "5tgMytDTlmpr", + "outputId": "068228d7-f34a-4335-99b5-3f4c8edc7466" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Ridge model coef: [[ 0.00947064 0.20687242 -0.11623737 -0.6366149 0.02528395 0.37704409\n", + " -0.12085268 0.10023402 0.04861364]]\n" + ] + } + ], + "source": [ + "#alpha factor here is lambda (penalty term) which helps to reduce the magnitude of coeff\n", + "\n", + "ridge_model = Ridge(alpha = 0.3)\n", + "ridge_model.fit(X_train, y_train)\n", + "\n", + "print(f'Ridge model coef: {ridge_model.coef_}')\n", + "#As the data has 10 columns hence 10 coefficients appear here " + ] + }, + { + "cell_type": "code", + "execution_count": 151, + "metadata": { + "colab": {}, + "colab_type": "code", + "id": "O3y8eJ0slmpv" + }, + "outputs": [], + "source": [ + "# Regularized Lasso Regression" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": { + "colab": {}, + "colab_type": "code", + "id": "5F1M2L_ylmpx", + "outputId": "f987a2b2-a9b5-4816-d6f7-1a9a8b2a72f0" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Lasso model coef: [ 0.00728877 0.19201382 -0.11069878 -0.62910384 0.02365075 0.37598182\n", + " -0.17839937 0.04919513 0. ]\n" + ] + } + ], + "source": [ + "#alpha factor here is lambda (penalty term) which helps to reduce the magnitude of coeff\n", + "\n", + "lasso_model = Lasso(alpha = 0.001)\n", + "lasso_model.fit(X_train, y_train)\n", + "\n", + "print(f'Lasso model coef: {lasso_model.coef_}')\n", + "#As the data has 10 columns hence 10 coefficients appear here " + ] + }, + { + "cell_type": "code", + "execution_count": 66, + "metadata": { + "colab": {}, + "colab_type": "code", + "id": "F2KmGpNXlmp0" + }, + "outputs": [], + "source": [ + "# Score Comparison" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": { + "colab": {}, + "colab_type": "code", + "id": "8YBStPwilmp3", + "outputId": "08dd9aba-9341-4afa-c3f6-a2ab96bdc325" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Simple Train: 0.815778380699972\n", + "Simple Test: 0.8244176296131174\n", + "*************************\n", + "Lasso Train: 0.815720478596037\n", + "Lasso Test: 0.824524813598757\n", + "*************************\n", + "Ridge Train: 0.8157699657350654\n", + "Ridge Test: 0.8239615515502365\n" + ] + } + ], + "source": [ + "#Model score - r^2 or coeff of determinant\n", + "#r^2 = 1-(RSS/TSS) = Regression error/TSS \n", + "\n", + "\n", + "#Simple Linear Model\n", + "print(\"Simple Train: \", regression_model.score(X_train, y_train))\n", + "print(\"Simple Test: \", regression_model.score(X_test, y_test))\n", + "print('*************************')\n", + "#Lasso\n", + "print(\"Lasso Train: \", lasso_model.score(X_train, y_train))\n", + "print(\"Lasso Test: \", lasso_model.score(X_test, y_test))\n", + "print('*************************')\n", + "#Ridge\n", + "print(\"Ridge Train: \", ridge_model.score(X_train, y_train))\n", + "print(\"Ridge Test: \", ridge_model.score(X_test, y_test))\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Resources\n", + "\n", + "https://towardsdatascience.com/regularization-in-machine-learning-76441ddcf99a " + ] + } + ], + "metadata": { + "colab": { + "collapsed_sections": [], + "include_colab_link": true, + "name": "r.ipynb", + "provenance": [] + }, + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.7.3" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/Regularization/regularization.ipynb b/Regularization/regularization.ipynb index 7b59912..9c9c351 100644 --- a/Regularization/regularization.ipynb +++ b/Regularization/regularization.ipynb @@ -1299,7 +1299,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.7.3" + "version": "3.7.9" } }, "nbformat": 4, diff --git a/Unsupervised Learning/.ipynb_checkpoints/unsupervised_learning-checkpoint.ipynb b/Unsupervised Learning/.ipynb_checkpoints/unsupervised_learning-checkpoint.ipynb new file mode 100644 index 0000000..d515b10 --- /dev/null +++ b/Unsupervised Learning/.ipynb_checkpoints/unsupervised_learning-checkpoint.ipynb @@ -0,0 +1,1019 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": { + "colab_type": "text", + "id": "view-in-github" + }, + "source": [ + "\n", + " \"Open\n", + "" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "colab_type": "text", + "id": "GyzG2YmSs89r" + }, + "source": [ + "# Clustering" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "colab_type": "text", + "id": "WmS8ct5vs89s" + }, + "source": [ + "Clustering can be considered the most important unsupervised learning problem; so, as every other problem of this kind, it deals with finding a structure in a collection of unlabeled data. A loose definition of clustering could be “the process of organizing objects into groups whose members are similar in some way”. A cluster is therefore a collection of objects which are “similar” between them and are “dissimilar” to the objects belonging to other clusters." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "colab_type": "text", + "id": "AyDGFgYgs89s" + }, + "source": [ + "" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "colab_type": "text", + "id": "BDGsmEBIs89t" + }, + "source": [ + "#### Types of Clustering" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "colab_type": "text", + "id": "75FkrRlts89u" + }, + "source": [ + "\"Centroid-based Clustering\" organizes the data into non-hierarchical clusters, in contrast to hierarchical clustering defined below. k-means is the most widely-used centroid-based clustering algorithm. Centroid-based algorithms are efficient but sensitive to initial conditions and outliers." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "colab_type": "text", + "id": "R7kc2Op3s89u" + }, + "source": [ + "" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "colab_type": "text", + "id": "tNSZvo3ts89u" + }, + "source": [ + "\"Density-based Clustering\" connects areas of high example density into clusters. This allows for arbitrary-shaped distributions as long as dense areas can be connected. These algorithms have difficulty with data of varying densities and high dimensions. Further, by design, these algorithms do not assign outliers to clusters." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "colab_type": "text", + "id": "NSqTRsYUs89v" + }, + "source": [ + "" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "colab_type": "text", + "id": "zJB0jOW5s89v" + }, + "source": [ + "\"Distribution-based Clustering\" approach assumes data is composed of distributions, such as Gaussian distributions. In the picture, the distribution-based algorithm clusters data into three Gaussian distributions. As distance from the distribution's center increases, the probability that a point belongs to the distribution decreases. The bands show that decrease in probability. When you do not know the type of distribution in your data, you should use a different algorithm." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "colab_type": "text", + "id": "nG0k0sDWs89w" + }, + "source": [ + "" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "colab_type": "text", + "id": "9IkgcrVEs89w" + }, + "source": [ + "\"Hierarchical clustering\" creates a tree of clusters. Hierarchical clustering, not surprisingly, is well suited to hierarchical data, such as taxonomies. " + ] + }, + { + "cell_type": "markdown", + "metadata": { + "colab_type": "text", + "id": "XCuBIfhfs89w" + }, + "source": [ + "" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "colab_type": "text", + "id": "cHGA4U1rs89x" + }, + "source": [ + "## K-Means Clustering" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "colab_type": "text", + "id": "x7PArFvQs89x" + }, + "source": [ + "The K-Means algorithm clusters data by trying to separate samples in n groups of equal variance, minimizing a criterion known as the inertia or within-cluster sum-of-squares. This algorithm requires the number of clusters to be specified. It scales well to large number of samples and has been used across a large range of application areas in many different fields." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "colab_type": "text", + "id": "tmG7LgDds89x" + }, + "source": [ + "The k-means algorithm divides a set of N samples X into K disjoint clusters C, each described by the mean $\\mu_j$\n", + " of the samples in the cluster. The means are commonly called the cluster “centroids”; note that they are not, in general, points from X, although they live in the same space." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "colab_type": "text", + "id": "IvvIYnNOs89y" + }, + "source": [ + "The K-means algorithm aims to choose centroids that minimise the inertia, or within-cluster sum-of-squares criterion:" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "colab_type": "text", + "id": "eomhyzRxs89y" + }, + "source": [ + "

" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "colab_type": "text", + "id": "PaLk-isXs89y" + }, + "source": [ + "" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "colab_type": "text", + "id": "HcRGNffYs89z" + }, + "source": [ + "#Step One" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "colab_type": "text", + "id": "6EhWH_t1s89z" + }, + "source": [ + "The algorithm randomly chooses a centroid for each cluster. In our example, we choose a k of 3, and therefore the algorithm randomly picks 3 centroids." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "colab_type": "text", + "id": "6eLi7FIXs89z" + }, + "source": [ + "" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "colab_type": "text", + "id": "cnb2x8c7s890" + }, + "source": [ + "#Step Two" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "colab_type": "text", + "id": "aMZfgFGGs890" + }, + "source": [ + "The algorithm assigns each point to the closest centroid to get k initial clusters." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "colab_type": "text", + "id": "_qkwP2zas890" + }, + "source": [ + "" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "colab_type": "text", + "id": "rnpIjVfMs891" + }, + "source": [ + "#Step Three" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "colab_type": "text", + "id": "4cuTpWaJs891" + }, + "source": [ + "For every cluster, the algorithm recomputes the centroid by taking the average of all points in the cluster. The changes in centroids are shown in Figure 3 by arrows. Since the centroids change, the algorithm then re-assigns the points to the closest centroid. Figure 4 shows the new clusters after re-assignment." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "colab_type": "text", + "id": "W6qwozARs891" + }, + "source": [ + "" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "colab_type": "text", + "id": "hvjUagQLs892" + }, + "source": [ + "#Step Four" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "colab_type": "text", + "id": "X0AtQu60s892" + }, + "source": [ + "The algorithm repeats the calculation of centroids and assignment of points until points stop changing clusters. When clustering large datasets, you stop the algorithm before reaching convergence, using other criteria instead." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "colab_type": "text", + "id": "W07RLZ4Ws892" + }, + "source": [ + "" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "colab_type": "text", + "id": "IFEIUDv7s893" + }, + "source": [ + "#### K Means Parameters : https://scikit-learn.org/stable/modules/generated/sklearn.cluster.KMeans.html" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "colab_type": "text", + "id": "oLENs24Xs893" + }, + "source": [ + "#### Mini Batch K-Means" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "colab_type": "text", + "id": "EUDMd38ls893" + }, + "source": [ + "The MiniBatchKMeans is a variant of the KMeans algorithm which uses mini-batches to reduce the computation time, while still attempting to optimise the same objective function. Mini-batches are subsets of the input data, randomly sampled in each training iteration. These mini-batches drastically reduce the amount of computation required to converge to a local solution. In contrast to other algorithms that reduce the convergence time of k-means, mini-batch k-means produces results that are generally only slightly worse than the standard algorithm." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "colab_type": "text", + "id": "G5ODhTs8s893" + }, + "source": [ + "MiniBatchKMeans converges faster than KMeans, but the quality of the results is reduced. In practice this difference in quality can be quite small, as shown in the example and cited reference.\n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "colab_type": "text", + "id": "gjA6DTqbs894" + }, + "source": [ + "" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Example" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "colab": {}, + "colab_type": "code", + "id": "b5aRPk_Zs894" + }, + "outputs": [], + "source": [ + "import numpy as np\n", + "import pandas as pd\n", + "import matplotlib.pyplot as plt\n", + "import seaborn as sns" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Data" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": { + "colab": {}, + "colab_type": "code", + "id": "7sYybz9us898" + }, + "outputs": [], + "source": [ + "from sklearn.datasets import make_blobs\n", + "\n", + "X, y = make_blobs(n_samples=1000, n_features=2, cluster_std=5.5, random_state=42) " + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": { + "colab": {}, + "colab_type": "code", + "id": "FxY0w9sHs89_" + }, + "outputs": [], + "source": [ + "from sklearn.model_selection import train_test_split \n", + "\n", + "X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42) " + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[ 6.1086553 , -2.93325702, -1.38963414, ..., 0.32349635,\n", + " 4.88084193, -7.5865835 ],\n", + " [ 6.86613906, 10.89062199, -5.94711017, ..., 11.84010886,\n", + " 1.16465867, -17.23027934]])" + ] + }, + "execution_count": 12, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "X_train.T" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Plots" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "sns.set_style(\"whitegrid\")" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "sns.scatterplot(X_train.T[0], X_train.T[1],color='g')" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 13, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "sns.scatterplot(X_test.T[0], X_test.T[1],color='g')" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 14, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "sns.distplot(X_train.T[0])" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 15, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "sns.distplot(X_train.T[1])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Scaling" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [], + "source": [ + "from sklearn.preprocessing import StandardScaler\n", + "\n", + "scaler = StandardScaler().fit(X_train)\n", + "X_train_n = scaler.transform(X_train)\n", + "X_test_n = scaler.transform(X_test)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Model" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": { + "colab": {}, + "colab_type": "code", + "id": "MtTnveWEs8-D" + }, + "outputs": [], + "source": [ + "from sklearn.cluster import KMeans\n", + "\n", + "model = KMeans(n_clusters=1)" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": { + "colab": {}, + "colab_type": "code", + "id": "jraBTRB0s8-H", + "outputId": "c2d0ca2b-f8a6-4c92-92bb-04946f52eade" + }, + "outputs": [ + { + "data": { + "text/plain": [ + "KMeans(algorithm='auto', copy_x=True, init='k-means++', max_iter=300,\n", + " n_clusters=1, n_init=10, n_jobs=None, precompute_distances='auto',\n", + " random_state=None, tol=0.0001, verbose=0)" + ] + }, + "execution_count": 19, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "model.fit(X_train_n) " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Score" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": { + "colab": {}, + "colab_type": "code", + "id": "CY_-eShbs8-J", + "outputId": "4dbc6aa8-b42e-4a74-cd58-52a7fc3540dc" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Train score: -1600.000000000001\n", + "Test score: -375.1898042304475\n" + ] + } + ], + "source": [ + "# model score, Opposite of the value of X on the K-means objective.\n", + "print(\"Train score:\", model.score(X_train_n))\n", + "print(\"Test score:\",model.score(X_test_n))" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": { + "colab": {}, + "colab_type": "code", + "id": "e6p0mK2Ps8-M" + }, + "outputs": [], + "source": [ + "train=[]\n", + "test=[]\n", + "\n", + "for n in range(1, 10):\n", + " model = KMeans(n_clusters=n)\n", + " model.fit(X_train_n, y_train)\n", + " \n", + " train.append(model.score(X_train_n, y_train))\n", + " test.append(model.score(X_test_n, y_test))" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": { + "colab": {}, + "colab_type": "code", + "id": "stWbC65As8-O", + "outputId": "5eb2f4b9-fd47-4eb3-8236-f079a82a731a" + }, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.plot(train)\n", + "plt.plot(test)\n", + "plt.legend((\"train\", \"test\"))\n", + "plt.xticks(range(1, 33, 2))\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": {}, + "outputs": [], + "source": [ + "var = []\n", + "\n", + "for n in range(1, 10):\n", + " model = KMeans(n_clusters=n)\n", + " model.fit(X_train_n)\n", + " \n", + " var.append(model.inertia_) " + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[1600.000000000001,\n", + " 937.22924469758,\n", + " 592.4940471817132,\n", + " 484.6290107428904,\n", + " 404.09818257937934,\n", + " 345.79343614790093,\n", + " 302.78693683830807,\n", + " 266.712394146979,\n", + " 236.4394596476161]" + ] + }, + "execution_count": 24, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "var" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.plot(var)\n", + "plt.xticks(range(10), range(2,9))\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Sihouette Score\n", + "Silhouette Coefficient or silhouette score is a metric used to calculate the goodness of a clustering technique. Its value ranges from -1 to 1. \n", + "\n", + "1: Means clusters are well apart from each other and clearly distinguished. \n", + "\n", + "0: Means clusters are indifferent, or we can say that the distance between clusters is not significant. \n", + "\n", + "-1: Means clusters are assigned in the wrong way.\n", + "\n", + "![](img/sil.jpeg)\n", + "\n", + "Silhouette Score = $\\frac{(b-a)}{max(a,b)}$\n", + "\n", + "Where: \n", + "$a$: average intra-cluster distance i.e the average distance between each point within a cluster. \n", + "$b$: average inter-cluster distance i.e the average distance between all clusters." + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "### Code\n", + "from sklearn.metrics import silhouette_score\n", + "\n", + "silhouette = []\n", + "\n", + "for n in range(2, 10):\n", + " model = KMeans(n_clusters=n)\n", + " model.fit(X_train_n)\n", + " label=model.predict(X_train_n)\n", + " silhouette.append(silhouette_score(X_train_n,label))\n", + " \n", + "\n", + "ax = plt.plot(silhouette)\n", + "plt.xticks(range(8), range(2,10))\n", + "plt.title(\"Mean Sihouette Score for Each K\")\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 27, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Final run\n", + "\n", + "model = KMeans(n_clusters=3)\n", + "model.fit(X_train_n)\n", + "\n", + "clusters = model.predict(X_train_n)\n", + "sns.scatterplot(X_train_n.T[0], X_train_n.T[1], hue=clusters)\n", + "plt.scatter(x=model.cluster_centers_[0][0], y=model.cluster_centers_[0][1], color='r')\n", + "plt.scatter(x=model.cluster_centers_[1][0], y=model.cluster_centers_[1][1], color='r')\n", + "plt.scatter(x=model.cluster_centers_[2][0], y=model.cluster_centers_[2][1], color='r')" + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 28, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "sns.scatterplot(X_train.T[0], X_train.T[1],color='g')" + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[-0.26104373, 0.98223569],\n", + " [-0.84175757, -0.97962535],\n", + " [ 1.04528306, -0.02746083]])" + ] + }, + "execution_count": 29, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "model.cluster_centers_" + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 30, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "cluster_test = model.predict(X_test_n)\n", + "sns.scatterplot(X_test_n.T[0], X_test_n.T[1], hue=cluster_test)\n", + "plt.scatter(x=model.cluster_centers_[0][0], y=model.cluster_centers_[0][1], color='r')\n", + "plt.scatter(x=model.cluster_centers_[1][0], y=model.cluster_centers_[1][1], color='r')\n", + "plt.scatter(x=model.cluster_centers_[2][0], y=model.cluster_centers_[2][1], color='r')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Resources\n", + "\n", + "https://realpython.com/k-means-clustering-python/ " + ] + } + ], + "metadata": { + "colab": { + "include_colab_link": true, + "name": "ul.ipynb", + "provenance": [] + }, + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.7.3" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/Unsupervised Learning/unsupervised_learning.ipynb b/Unsupervised Learning/unsupervised_learning.ipynb index d515b10..eef2a50 100644 --- a/Unsupervised Learning/unsupervised_learning.ipynb +++ b/Unsupervised Learning/unsupervised_learning.ipynb @@ -1011,7 +1011,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.7.3" + "version": "3.7.9" } }, "nbformat": 4,