\n",
+ "\n",
+ "# Decision Trees\n",
+ "\n",
+ "Estimated time needed: **15** minutes\n",
+ "\n",
+ "## Objectives\n",
+ "\n",
+ "After completing this lab you will be able to:\n",
+ "\n",
+ "* Develop a classification model using Decision Tree Algorithm\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "In this lab exercise, you will learn a popular machine learning algorithm, Decision Trees. You will use this classification algorithm to build a model from the historical data of patients, and their response to different medications. Then you will use the trained decision tree to predict the class of an unknown patient, or to find a proper drug for a new patient.\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "
\n",
+ " Imagine that you are a medical researcher compiling data for a study. You have collected data about a set of patients, all of whom suffered from the same illness. During their course of treatment, each patient responded to one of 5 medications, Drug A, Drug B, Drug c, Drug x and y. \n",
+ " \n",
+ " \n",
+ " Part of your job is to build a model to find out which drug might be appropriate for a future patient with the same illness. The features of this dataset are Age, Sex, Blood Pressure, and the Cholesterol of the patients, and the target is the drug that each patient responded to.\n",
+ " \n",
+ " \n",
+ " It is a sample of multiclass classifier, and you can use the training part of the dataset \n",
+ " to build a decision tree, and then use it to predict the class of an unknown patient, or to prescribe a drug to a new patient.\n",
+ "
"
+ ],
+ "text/plain": [
+ " Age Sex BP Cholesterol Na_to_K Drug\n",
+ "0 23 F HIGH HIGH 25.355 drugY\n",
+ "1 47 M LOW HIGH 13.093 drugC\n",
+ "2 47 M LOW HIGH 10.114 drugC\n",
+ "3 28 F NORMAL HIGH 7.798 drugX\n",
+ "4 61 F LOW HIGH 18.043 drugY\n",
+ "5 22 F NORMAL HIGH 8.607 drugX\n",
+ "6 49 F NORMAL HIGH 16.275 drugY\n",
+ "7 41 M LOW HIGH 11.037 drugC\n",
+ "8 60 M NORMAL HIGH 15.171 drugY\n",
+ "9 43 M LOW NORMAL 19.368 drugY\n",
+ "10 47 F LOW HIGH 11.767 drugC\n",
+ "11 34 F HIGH NORMAL 19.199 drugY\n",
+ "12 43 M LOW HIGH 15.376 drugY"
+ ]
+ },
+ "execution_count": 3,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "my_data = pd.read_csv('https://cf-courses-data.s3.us.cloud-object-storage.appdomain.cloud/IBMDeveloperSkillsNetwork-ML0101EN-SkillsNetwork/labs/Module%203/data/drug200.csv', delimiter=\",\")\n",
+ "my_data.head(13)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "
\n",
+ "The train_test_split will need the parameters: \n",
+ "X, y, test_size=0.3, and random_state=3.
\n",
+ "The X and y are the arrays required before the split, the test_size represents the ratio of the testing dataset, and the random_state ensures that we obtain the same splits.\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 9,
+ "metadata": {
+ "tags": []
+ },
+ "outputs": [],
+ "source": [
+ "X_trainset, X_testset, y_trainset, y_testset = train_test_split(X, y, test_size=0.3, random_state=3)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "tags": []
+ },
+ "source": [
+ "
Practice
\n",
+ "Print the shape of X_trainset and y_trainset. Ensure that the dimensions match.\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 10,
+ "metadata": {
+ "tags": []
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Shape of X training set (140, 5) & Size of Y training set (140,)\n"
+ ]
+ }
+ ],
+ "source": [
+ "print('Shape of X training set {}'.format(X_trainset.shape),'&',' Size of Y training set {}'.format(y_trainset.shape))\n",
+ "\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "Click here for the solution\n",
+ "\n",
+ "```python\n",
+ "print('Shape of X training set {}'.format(X_trainset.shape),'&',' Size of Y training set {}'.format(y_trainset.shape))\n",
+ "\n",
+ "```\n",
+ "\n",
+ "\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "Print the shape of X_testset and y_testset. Ensure that the dimensions match.\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 11,
+ "metadata": {
+ "tags": []
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Shape of X test set (60, 5) & Size of y test set (60,)\n"
+ ]
+ }
+ ],
+ "source": [
+ "print('Shape of X test set {}'.format(X_testset.shape),'&','Size of y test set {}'.format(y_testset.shape))\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "Click here for the solution\n",
+ "\n",
+ "```python\n",
+ "print('Shape of X test set {}'.format(X_testset.shape),'&','Size of y test set {}'.format(y_testset.shape))\n",
+ "\n",
+ "```\n",
+ "\n",
+ "\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "\n",
+ "\n",
+ "
\n",
+ "
Modeling
\n",
+ " We will first create an instance of the DecisionTreeClassifier called drugTree. \n",
+ " Inside of the classifier, specify criterion=\"entropy\" so we can see the information gain of each node.\n",
+ "
\n",
+ "\n",
+ "# K-Nearest Neighbors\n",
+ "\n",
+ "Estimated time needed: **25** minutes\n",
+ "\n",
+ "## Objectives\n",
+ "\n",
+ "After completing this lab you will be able to:\n",
+ "\n",
+ "* Use K Nearest neighbors to classify data\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "In this Lab you will load a customer dataset, fit the data, and use K-Nearest Neighbors to predict a data point. But what is **K-Nearest Neighbors**?\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "**K-Nearest Neighbors** is a supervised learning algorithm. Where the data is 'trained' with data points corresponding to their classification. To predict the class of a given data point, it takes into account the classes of the 'K' nearest data points and chooses the class in which the majority of the 'K' nearest data points belong to as the predicted class.\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "### Here's an visualization of the K-Nearest Neighbors algorithm.\n",
+ "\n",
+ "\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "In this case, we have data points of Class A and B. We want to predict what the star (test data point) is. If we consider a k value of 3 (3 nearest data points), we will obtain a prediction of Class B. Yet if we consider a k value of 6, we will obtain a prediction of Class A.\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "In this sense, it is important to consider the value of k. Hopefully from this diagram, you should get a sense of what the K-Nearest Neighbors algorithm is. It considers the 'K' Nearest Neighbors (data points) when it predicts the classification of the test point.\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "
\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "Imagine a telecommunications provider has segmented its customer base by service usage patterns, categorizing the customers into four groups. If demographic data can be used to predict group membership, the company can customize offers for individual prospective customers. It is a classification problem. That is, given the dataset, with predefined labels, we need to build a model to be used to predict class of a new or unknown case.\n",
+ "\n",
+ "The example focuses on using demographic data, such as region, age, and marital, to predict usage patterns.\n",
+ "\n",
+ "The target field, called **custcat**, has four possible values that correspond to the four customer groups, as follows:\n",
+ "1- Basic Service\n",
+ "2- E-Service\n",
+ "3- Plus Service\n",
+ "4- Total Service\n",
+ "\n",
+ "Our objective is to build a classifier, to predict the class of unknown cases. We will use a specific type of classification called K nearest neighbour.\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "### Load Data \n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "Let's read the data using pandas library and print the first five rows.\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 3,
+ "metadata": {
+ "tags": []
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/html": [
+ "
\n",
+ "\n",
+ "\n",
+ "# Logistic Regression with Python\n",
+ "\n",
+ "\n",
+ "Estimated time needed: **25** minutes\n",
+ " \n",
+ "\n",
+ "## Objectives\n",
+ "\n",
+ "After completing this lab you will be able to:\n",
+ "\n",
+ "* Use scikit Logistic Regression to classify\n",
+ "* Understand confusion matrix\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "In this notebook, you will learn Logistic Regression, and then, you'll create a model for a telecommunication company, to predict when its customers will leave for a competitor, so that they can take some action to retain the customers.\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "
\n",
+ " \n",
+ "\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "\n",
+ "## What is the difference between Linear and Logistic Regression?\n",
+ "\n",
+ "While Linear Regression is suited for estimating continuous values (e.g. estimating house price), it is not the best tool for predicting the class of an observed data point. In order to estimate the class of a data point, we need some sort of guidance on what would be the most probable class for that data point. For this, we use Logistic Regression.\n",
+ "\n",
+ "
\n",
+ "Recall linear regression:\n",
+ " \n",
+ " \n",
+ " As you know, Linear regression finds a function that relates a continuous dependent variable, y, to some predictors (independent variables $x_1$, $x_2$, etc.). For example, simple linear regression assumes a function of the form:\n",
+ "
\n",
+ "$$\n",
+ "y = \\theta_0 + \\theta_1 x_1 + \\theta_2 x_2 + \\cdots\n",
+ "$$\n",
+ " \n",
+ "and finds the values of parameters $\\theta_0, \\theta_1, \\theta_2$, etc, where the term $\\theta_0$ is the \"intercept\". It can be generally shown as:\n",
+ "
\n",
+ "\n",
+ "Logistic Regression is a variation of Linear Regression, used when the observed dependent variable, y, is categorical. It produces a formula that predicts the probability of the class label as a function of the independent variables.\n",
+ "\n",
+ "Logistic regression fits a special s-shaped curve by taking the linear regression function and transforming the numeric estimate into a probability with the following function, which is called the sigmoid function 𝜎:\n",
+ "\n",
+ "$$\n",
+ "ℎ_\\theta(𝑥) = \\sigma({\\theta^TX}) = \\frac {e^{(\\theta_0 + \\theta_1 x_1 + \\theta_2 x_2 +...)}}{1 + e^{(\\theta_0 + \\theta_1 x_1 + \\theta_2 x_2 +\\cdots)}}\n",
+ "$$\n",
+ "Or:\n",
+ "$$\n",
+ "ProbabilityOfaClass_1 = P(Y=1|X) = \\sigma({\\theta^TX}) = \\frac{e^{\\theta^TX}}{1+e^{\\theta^TX}} \n",
+ "$$\n",
+ "\n",
+ "In this equation, ${\\theta^TX}$ is the regression result (the sum of the variables weighted by the coefficients), `exp` is the exponential function and $\\sigma(\\theta^TX)$ is the sigmoid or [logistic function](http://en.wikipedia.org/wiki/Logistic_function), also called logistic curve. It is a common \"S\" shape (sigmoid curve).\n",
+ "\n",
+ "So, briefly, Logistic Regression passes the input through the logistic/sigmoid but then treats the result as a probability:\n",
+ "\n",
+ "\n",
+ "\n",
+ "\n",
+ "The objective of the __Logistic Regression__ algorithm, is to find the best parameters θ, for $ℎ_\\theta(𝑥)$ = $\\sigma({\\theta^TX})$, in such a way that the model best predicts the class of each case.\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "### Customer churn with Logistic Regression\n",
+ "A telecommunications company is concerned about the number of customers leaving their land-line business for cable competitors. They need to understand who is leaving. Imagine that you are an analyst at this company and you have to find out who is leaving and why.\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 1,
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Requirement already satisfied: scikit-learn in /opt/conda/lib/python3.12/site-packages (1.7.2)\n",
+ "Requirement already satisfied: numpy>=1.22.0 in /opt/conda/lib/python3.12/site-packages (from scikit-learn) (2.3.4)\n",
+ "Requirement already satisfied: scipy>=1.8.0 in /opt/conda/lib/python3.12/site-packages (from scikit-learn) (1.16.2)\n",
+ "Requirement already satisfied: joblib>=1.2.0 in /opt/conda/lib/python3.12/site-packages (from scikit-learn) (1.5.2)\n",
+ "Requirement already satisfied: threadpoolctl>=3.1.0 in /opt/conda/lib/python3.12/site-packages (from scikit-learn) (3.6.0)\n",
+ "Requirement already satisfied: matplotlib in /opt/conda/lib/python3.12/site-packages (3.10.7)\n",
+ "Requirement already satisfied: contourpy>=1.0.1 in /opt/conda/lib/python3.12/site-packages (from matplotlib) (1.3.3)\n",
+ "Requirement already satisfied: cycler>=0.10 in /opt/conda/lib/python3.12/site-packages (from matplotlib) (0.12.1)\n",
+ "Requirement already satisfied: fonttools>=4.22.0 in /opt/conda/lib/python3.12/site-packages (from matplotlib) (4.60.1)\n",
+ "Requirement already satisfied: kiwisolver>=1.3.1 in /opt/conda/lib/python3.12/site-packages (from matplotlib) (1.4.9)\n",
+ "Requirement already satisfied: numpy>=1.23 in /opt/conda/lib/python3.12/site-packages (from matplotlib) (2.3.4)\n",
+ "Requirement already satisfied: packaging>=20.0 in /opt/conda/lib/python3.12/site-packages (from matplotlib) (24.2)\n",
+ "Requirement already satisfied: pillow>=8 in /opt/conda/lib/python3.12/site-packages (from matplotlib) (12.0.0)\n",
+ "Requirement already satisfied: pyparsing>=3 in /opt/conda/lib/python3.12/site-packages (from matplotlib) (3.2.5)\n",
+ "Requirement already satisfied: python-dateutil>=2.7 in /opt/conda/lib/python3.12/site-packages (from matplotlib) (2.9.0.post0)\n",
+ "Requirement already satisfied: six>=1.5 in /opt/conda/lib/python3.12/site-packages (from python-dateutil>=2.7->matplotlib) (1.17.0)\n",
+ "Requirement already satisfied: pandas in /opt/conda/lib/python3.12/site-packages (2.3.3)\n",
+ "Requirement already satisfied: numpy>=1.26.0 in /opt/conda/lib/python3.12/site-packages (from pandas) (2.3.4)\n",
+ "Requirement already satisfied: python-dateutil>=2.8.2 in /opt/conda/lib/python3.12/site-packages (from pandas) (2.9.0.post0)\n",
+ "Requirement already satisfied: pytz>=2020.1 in /opt/conda/lib/python3.12/site-packages (from pandas) (2024.2)\n",
+ "Requirement already satisfied: tzdata>=2022.7 in /opt/conda/lib/python3.12/site-packages (from pandas) (2025.2)\n",
+ "Requirement already satisfied: six>=1.5 in /opt/conda/lib/python3.12/site-packages (from python-dateutil>=2.8.2->pandas) (1.17.0)\n",
+ "Requirement already satisfied: numpy in /opt/conda/lib/python3.12/site-packages (2.3.4)\n"
+ ]
+ }
+ ],
+ "source": [
+ "#!pip install scikit-learn==0.23.1\n",
+ "!pip install scikit-learn\n",
+ "!pip install matplotlib\n",
+ "!pip install pandas \n",
+ "!pip install numpy \n",
+ "%matplotlib inline"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "Let's first import required libraries:\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 2,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "import pandas as pd\n",
+ "import pylab as pl\n",
+ "import numpy as np\n",
+ "import scipy.optimize as opt\n",
+ "from sklearn import preprocessing\n",
+ "%matplotlib inline \n",
+ "import matplotlib.pyplot as plt"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "
About the dataset
\n",
+ "We will use a telecommunications dataset for predicting customer churn. This is a historical customer dataset where each row represents one customer. The data is relatively easy to understand, and you may uncover insights you can use immediately. Typically it is less expensive to keep customers than acquire new ones, so the focus of this analysis is to predict the customers who will stay with the company. \n",
+ "\n",
+ "\n",
+ "This data set provides information to help you predict what behavior will help you to retain customers. You can analyze all relevant customer data and develop focused customer retention programs.\n",
+ "\n",
+ "\n",
+ "\n",
+ "The dataset includes information about:\n",
+ "\n",
+ "- Customers who left within the last month – the column is called Churn\n",
+ "- Services that each customer has signed up for – phone, multiple lines, internet, online security, online backup, device protection, tech support, and streaming TV and movies\n",
+ "- Customer account information – how long they had been a customer, contract, payment method, paperless billing, monthly charges, and total charges\n",
+ "- Demographic info about customers – gender, age range, and if they have partners and dependents\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "### Load the Telco Churn data \n",
+ "Telco Churn is a hypothetical data file that concerns a telecommunications company's efforts to reduce turnover in its customer base. Each case corresponds to a separate customer and it records various demographic and service usage information. Before you can work with the data, you must use the URL to get the ChurnData.csv.\n",
+ "\n",
+ "To download the data, we will use `!wget` to download it from IBM Object Storage.\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 3,
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "--2025-10-20 14:53:44-- https://cf-courses-data.s3.us.cloud-object-storage.appdomain.cloud/IBMDeveloperSkillsNetwork-ML0101EN-SkillsNetwork/labs/Module%203/data/ChurnData.csv\n",
+ "Resolving cf-courses-data.s3.us.cloud-object-storage.appdomain.cloud (cf-courses-data.s3.us.cloud-object-storage.appdomain.cloud)... 169.63.118.104\n",
+ "Connecting to cf-courses-data.s3.us.cloud-object-storage.appdomain.cloud (cf-courses-data.s3.us.cloud-object-storage.appdomain.cloud)|169.63.118.104|:443... connected.\n",
+ "200 OKequest sent, awaiting response... \n",
+ "Length: 35943 (35K) [text/csv]\n",
+ "Saving to: ‘ChurnData.csv’\n",
+ "\n",
+ "ChurnData.csv 100%[===================>] 35.10K --.-KB/s in 0.001s \n",
+ "\n",
+ "2025-10-20 14:53:44 (45.6 MB/s) - ‘ChurnData.csv’ saved [35943/35943]\n",
+ "\n"
+ ]
+ }
+ ],
+ "source": [
+ "#Click here and press Shift+Enter\n",
+ "!wget -O ChurnData.csv https://cf-courses-data.s3.us.cloud-object-storage.appdomain.cloud/IBMDeveloperSkillsNetwork-ML0101EN-SkillsNetwork/labs/Module%203/data/ChurnData.csv"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "## Load Data From CSV File \n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 4,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/html": [
+ "
\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "Let's select some features for the modeling. Also, we change the target data type to be an integer, as it is a requirement by the skitlearn algorithm:\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 6,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/html": [
+ "
\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "Let's build our model using __LogisticRegression__ from the Scikit-learn package. This function implements logistic regression and can use different numerical optimizers to find parameters, including ‘newton-cg’, ‘lbfgs’, ‘liblinear’, ‘sag’, ‘saga’ solvers. You can find extensive information about the pros and cons of these optimizers if you search it in the internet.\n",
+ "\n",
+ "The version of Logistic Regression in Scikit-learn, support regularization. Regularization is a technique used to solve the overfitting problem of machine learning models.\n",
+ "__C__ parameter indicates __inverse of regularization strength__ which must be a positive float. Smaller values specify stronger regularization. \n",
+ "Now let's fit our model with train set:\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 12,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/html": [
+ "
LogisticRegression(C=0.01, solver='liblinear')
In a Jupyter environment, please rerun this cell to show the HTML representation or trust the notebook. On GitHub, the HTML representation is unable to render, please try loading this page with nbviewer.org.
\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "### jaccard index\n",
+ "Let's try the jaccard index for accuracy evaluation. we can define jaccard as the size of the intersection divided by the size of the union of the two label sets. If the entire set of predicted labels for a sample strictly matches with the true set of labels, then the subset accuracy is 1.0; otherwise it is 0.0.\n",
+ "\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 15,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "0.7058823529411765"
+ ]
+ },
+ "execution_count": 15,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "from sklearn.metrics import jaccard_score\n",
+ "jaccard_score(y_test, yhat,pos_label=0)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "### confusion matrix\n",
+ "Another way of looking at the accuracy of the classifier is to look at __confusion matrix__.\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 16,
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "[[ 6 9]\n",
+ " [ 1 24]]\n"
+ ]
+ }
+ ],
+ "source": [
+ "from sklearn.metrics import classification_report, confusion_matrix\n",
+ "import itertools\n",
+ "def plot_confusion_matrix(cm, classes,\n",
+ " normalize=False,\n",
+ " title='Confusion matrix',\n",
+ " cmap=plt.cm.Blues):\n",
+ " \"\"\"\n",
+ " This function prints and plots the confusion matrix.\n",
+ " Normalization can be applied by setting `normalize=True`.\n",
+ " \"\"\"\n",
+ " if normalize:\n",
+ " cm = cm.astype('float') / cm.sum(axis=1)[:, np.newaxis]\n",
+ " print(\"Normalized confusion matrix\")\n",
+ " else:\n",
+ " print('Confusion matrix, without normalization')\n",
+ "\n",
+ " print(cm)\n",
+ "\n",
+ " plt.imshow(cm, interpolation='nearest', cmap=cmap)\n",
+ " plt.title(title)\n",
+ " plt.colorbar()\n",
+ " tick_marks = np.arange(len(classes))\n",
+ " plt.xticks(tick_marks, classes, rotation=45)\n",
+ " plt.yticks(tick_marks, classes)\n",
+ "\n",
+ " fmt = '.2f' if normalize else 'd'\n",
+ " thresh = cm.max() / 2.\n",
+ " for i, j in itertools.product(range(cm.shape[0]), range(cm.shape[1])):\n",
+ " plt.text(j, i, format(cm[i, j], fmt),\n",
+ " horizontalalignment=\"center\",\n",
+ " color=\"white\" if cm[i, j] > thresh else \"black\")\n",
+ "\n",
+ " plt.tight_layout()\n",
+ " plt.ylabel('True label')\n",
+ " plt.xlabel('Predicted label')\n",
+ "print(confusion_matrix(y_test, yhat, labels=[1,0]))"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 17,
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Confusion matrix, without normalization\n",
+ "[[ 6 9]\n",
+ " [ 1 24]]\n"
+ ]
+ },
+ {
+ "data": {
+ "image/png": "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",
+ "text/plain": [
+ "
"
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "# Compute confusion matrix\n",
+ "cnf_matrix = confusion_matrix(y_test, yhat, labels=[1,0])\n",
+ "np.set_printoptions(precision=2)\n",
+ "\n",
+ "\n",
+ "# Plot non-normalized confusion matrix\n",
+ "plt.figure()\n",
+ "plot_confusion_matrix(cnf_matrix, classes=['churn=1','churn=0'],normalize= False, title='Confusion matrix')"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "Let's look at first row. The first row is for customers whose actual churn value in the test set is 1.\n",
+ "As you can calculate, out of 40 customers, the churn value of 15 of them is 1. \n",
+ "Out of these 15 cases, the classifier correctly predicted 6 of them as 1, and 9 of them as 0. \n",
+ "\n",
+ "This means, for 6 customers, the actual churn value was 1 in test set and classifier also correctly predicted those as 1. However, while the actual label of 9 customers was 1, the classifier predicted those as 0, which is not very good. We can consider it as the error of the model for first row.\n",
+ "\n",
+ "What about the customers with churn value 0? Lets look at the second row.\n",
+ "It looks like there were 25 customers whom their churn value were 0. \n",
+ "\n",
+ "\n",
+ "The classifier correctly predicted 24 of them as 0, and one of them wrongly as 1. So, it has done a good job in predicting the customers with churn value 0. A good thing about the confusion matrix is that it shows the model’s ability to correctly predict or separate the classes. In a specific case of the binary classifier, such as this example, we can interpret these numbers as the count of true positives, false positives, true negatives, and false negatives. \n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 18,
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ " precision recall f1-score support\n",
+ "\n",
+ " 0 0.73 0.96 0.83 25\n",
+ " 1 0.86 0.40 0.55 15\n",
+ "\n",
+ " accuracy 0.75 40\n",
+ " macro avg 0.79 0.68 0.69 40\n",
+ "weighted avg 0.78 0.75 0.72 40\n",
+ "\n"
+ ]
+ }
+ ],
+ "source": [
+ "print (classification_report(y_test, yhat))\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "Based on the count of each section, we can calculate precision and recall of each label:\n",
+ "\n",
+ "\n",
+ "- __Precision__ is a measure of the accuracy provided that a class label has been predicted. It is defined by: precision = TP / (TP + FP)\n",
+ "\n",
+ "- __Recall__ is the true positive rate. It is defined as: Recall = TP / (TP + FN)\n",
+ "\n",
+ " \n",
+ "So, we can calculate the precision and recall of each class.\n",
+ "\n",
+ "__F1 score:__\n",
+ "Now we are in the position to calculate the F1 scores for each label based on the precision and recall of that label. \n",
+ "\n",
+ "The F1 score is the harmonic average of the precision and recall, where an F1 score reaches its best value at 1 (perfect precision and recall) and worst at 0. It is a good way to show that a classifer has a good value for both recall and precision.\n",
+ "\n",
+ "\n",
+ "Finally, we can tell the average accuracy for this classifier is the average of the F1-score for both labels, which is 0.72 in our case.\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "### log loss\n",
+ "Now, let's try __log loss__ for evaluation. In logistic regression, the output can be the probability of customer churn is yes (or equals to 1). This probability is a value between 0 and 1.\n",
+ "Log loss( Logarithmic loss) measures the performance of a classifier where the predicted output is a probability value between 0 and 1. \n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 19,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "0.6017092478101185"
+ ]
+ },
+ "execution_count": 19,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "from sklearn.metrics import log_loss\n",
+ "log_loss(y_test, yhat_prob)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "
Practice
\n",
+ "Try to build Logistic Regression model again for the same dataset, but this time, use different __solver__ and __regularization__ values? What is new __logLoss__ value?\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 20,
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "LogLoss: : 0.61\n"
+ ]
+ }
+ ],
+ "source": [
+ "LR2 = LogisticRegression(C=0.01, solver='sag').fit(X_train,y_train)\n",
+ "yhat_prob2 = LR2.predict_proba(X_test)\n",
+ "print (\"LogLoss: : %.2f\" % log_loss(y_test, yhat_prob2))\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "Click here for the solution\n",
+ "\n",
+ "```python\n",
+ "LR2 = LogisticRegression(C=0.01, solver='sag').fit(X_train,y_train)\n",
+ "yhat_prob2 = LR2.predict_proba(X_test)\n",
+ "print (\"LogLoss: : %.2f\" % log_loss(y_test, yhat_prob2))\n",
+ "\n",
+ "```\n",
+ "\n",
+ "\n",
+ "\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "### Thank you for completing this lab!\n",
+ "\n",
+ "\n",
+ "## Author\n",
+ "\n",
+ "Saeed Aghabozorgi\n",
+ "\n",
+ "\n",
+ "### Other Contributors\n",
+ "\n",
+ "Joseph Santarcangelo\n",
+ "\n",
+ "##
\n",
+ "\n",
+ "\n",
+ "# Non Linear Regression Analysis\n",
+ "\n",
+ "\n",
+ "Estimated time needed: **20** minutes\n",
+ " \n",
+ "\n",
+ "## Objectives\n",
+ "\n",
+ "After completing this lab you will be able to:\n",
+ "\n",
+ "* Differentiate between linear and non-linear regression\n",
+ "* Use non-linear regression model in Python\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "If the data shows a curvy trend, then linear regression will not produce very accurate results when compared to a non-linear regression since linear regression presumes that the data is linear. \n",
+ "Let's learn about non linear regressions and apply an example in python. In this notebook, we fit a non-linear model to the datapoints corrensponding to China's GDP from 1960 to 2014. \n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "
Importing required libraries
\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 1,
+ "metadata": {
+ "tags": []
+ },
+ "outputs": [],
+ "source": [
+ "import numpy as np\n",
+ "import matplotlib.pyplot as plt\n",
+ "%matplotlib inline"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "Although linear regression can do a great job at modeling some datasets, it cannot be used for all datasets. First recall how linear regression, models a dataset. It models the linear relationship between a dependent variable y and the independent variables x. It has a simple equation, of degree 1, for example y = $2x$ + 3.\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 2,
+ "metadata": {
+ "tags": []
+ },
+ "outputs": [
+ {
+ "data": {
+ "image/png": "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\n",
+ "text/plain": [
+ "
"
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "x = np.arange(-5.0, 5.0, 0.1)\n",
+ "\n",
+ "y = 2*(x) + 3\n",
+ "y_noise = 2 * np.random.normal(size=x.size)\n",
+ "ydata = y + y_noise\n",
+ "#plt.figure(figsize=(8,6))\n",
+ "plt.plot(x, ydata, 'bo')\n",
+ "plt.plot(x,y, 'r') \n",
+ "plt.ylabel('Dependent Variable')\n",
+ "plt.xlabel('Independent Variable')\n",
+ "plt.show()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "Non-linear regression is a method to model the non-linear relationship between the independent variables $x$ and the dependent variable $y$. Essentially any relationship that is not linear can be termed as non-linear, and is usually represented by the polynomial of $k$ degrees (maximum power of $x$). For example:\n",
+ "\n",
+ "$$ \\ y = a x^3 + b x^2 + c x + d \\ $$\n",
+ "\n",
+ "Non-linear functions can have elements like exponentials, logarithms, fractions, and so on. For example: $$ y = \\log(x)$$\n",
+ " \n",
+ "We can have a function that's even more complicated such as :\n",
+ "$$ y = \\log(a x^3 + b x^2 + c x + d)$$\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "Let's take a look at a cubic function's graph.\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 3,
+ "metadata": {
+ "tags": []
+ },
+ "outputs": [
+ {
+ "data": {
+ "image/png": "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\n",
+ "text/plain": [
+ "
"
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "x = np.arange(-5.0, 5.0, 0.1)\n",
+ "\n",
+ "\n",
+ "y = 1*(x**3) + 1*(x**2) + 1*x + 3\n",
+ "y_noise = 20 * np.random.normal(size=x.size)\n",
+ "ydata = y + y_noise\n",
+ "plt.plot(x, ydata, 'bo')\n",
+ "plt.plot(x,y, 'r') \n",
+ "plt.ylabel('Dependent Variable')\n",
+ "plt.xlabel('Independent Variable')\n",
+ "plt.show()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "As you can see, this function has $x^3$ and $x^2$ as independent variables. Also, the graphic of this function is not a straight line over the 2D plane. So this is a non-linear function.\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "Some other types of non-linear functions are:\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "tags": []
+ },
+ "source": [
+ "### Quadratic\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "$$ Y = X^2 $$\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 4,
+ "metadata": {
+ "tags": []
+ },
+ "outputs": [
+ {
+ "data": {
+ "image/png": "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\n",
+ "text/plain": [
+ "
"
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "x = np.arange(-5.0, 5.0, 0.1)\n",
+ "\n",
+ "\n",
+ "\n",
+ "y = np.power(x,2)\n",
+ "y_noise = 2 * np.random.normal(size=x.size)\n",
+ "ydata = y + y_noise\n",
+ "plt.plot(x, ydata, 'bo')\n",
+ "plt.plot(x,y, 'r') \n",
+ "plt.ylabel('Dependent Variable')\n",
+ "plt.xlabel('Independent Variable')\n",
+ "plt.show()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "### Exponential\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "An exponential function with base c is defined by $$ Y = a + b c^X$$ where b ≠0, c > 0 , c ≠1, and x is any real number. The base, c, is constant and the exponent, x, is a variable. \n",
+ "\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 5,
+ "metadata": {
+ "tags": []
+ },
+ "outputs": [
+ {
+ "data": {
+ "image/png": "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\n",
+ "text/plain": [
+ "
"
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "X = np.arange(-5.0, 5.0, 0.1)\n",
+ "\n",
+ "\n",
+ "\n",
+ "Y= np.exp(X)\n",
+ "\n",
+ "plt.plot(X,Y) \n",
+ "plt.ylabel('Dependent Variable')\n",
+ "plt.xlabel('Independent Variable')\n",
+ "plt.show()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "### Logarithmic\n",
+ "\n",
+ "The response $y$ is a results of applying the logarithmic map from the input $x$ to the output $y$. It is one of the simplest form of __log()__: i.e. $$ y = \\log(x)$$\n",
+ "\n",
+ "Please consider that instead of $x$, we can use $X$, which can be a polynomial representation of the $x$ values. In general form it would be written as \n",
+ "\\begin{equation}\n",
+ "y = \\log(X)\n",
+ "\\end{equation}\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 6,
+ "metadata": {
+ "tags": []
+ },
+ "outputs": [
+ {
+ "data": {
+ "image/png": "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\n",
+ "text/plain": [
+ "
\n",
+ "\n",
+ "IBM SPSS Modeler is a comprehensive analytics platform that has many machine learning algorithms. It has been designed to bring predictive intelligence to decisions made by individuals, by groups, by systems – by your enterprise as a whole. A free trial is available through this course, available here: SPSS Modeler\n",
+ "\n",
+ "Also, you can use Watson Studio to run these notebooks faster with bigger datasets. Watson Studio is IBM's leading cloud solution for data scientists, built by data scientists. With Jupyter notebooks, RStudio, Apache Spark and popular libraries pre-packaged in the cloud, Watson Studio enables data scientists to collaborate on their projects without having to install anything. Join the fast-growing community of Watson Studio users today with a free account at Watson Studio\n",
+ "\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "### Thank you for completing this lab!\n",
+ "\n",
+ "\n",
+ "## Author\n",
+ "\n",
+ "Saeed Aghabozorgi\n",
+ "\n",
+ "\n",
+ "### Other Contributors\n",
+ "\n",
+ "Joseph Santarcangelo\n",
+ "\n",
+ "\n",
+ "##
![\"Skills](\"https://cf-courses-data.s3.us.cloud-object-storage.appdomain.cloud/assets/logos/SN_web_lightmode.png\")
\n",
+ " \n",
+ "![](\"https://cf-courses-data.s3.us.cloud-object-storage.appdomain.cloud/IBMDeveloperSkillsNetwork-ML0101EN-SkillsNetwork/labs/Module%203/images/KNN_Diagram.png\")
\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "In this case, we have data points of Class A and B. We want to predict what the star (test data point) is. If we consider a k value of 3 (3 nearest data points), we will obtain a prediction of Class B. Yet if we consider a k value of 6, we will obtain a prediction of Class A.\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "In this sense, it is important to consider the value of k. Hopefully from this diagram, you should get a sense of what the K-Nearest Neighbors algorithm is. It considers the 'K' Nearest Neighbors (data points) when it predicts the classification of the test point.\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "![](\"https://cf-courses-data.s3.us.cloud-object-storage.appdomain.cloud/IBMDeveloperSkillsNetwork-ML0101EN-SkillsNetwork/labs/Module%203/images/mod_ID_24_final.png\")
\n",
+ "\n",
+ "\n",
+ "The objective of the __Logistic Regression__ algorithm, is to find the best parameters θ, for $ℎ_\\theta(𝑥)$ = $\\sigma({\\theta^TX})$, in such a way that the model best predicts the class of each case.\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "### Customer churn with Logistic Regression\n",
+ "A telecommunications company is concerned about the number of customers leaving their land-line business for cable competitors. They need to understand who is leaving. Imagine that you are an analyst at this company and you have to find out who is leaving and why.\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 1,
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Requirement already satisfied: scikit-learn in /opt/conda/lib/python3.12/site-packages (1.7.2)\n",
+ "Requirement already satisfied: numpy>=1.22.0 in /opt/conda/lib/python3.12/site-packages (from scikit-learn) (2.3.4)\n",
+ "Requirement already satisfied: scipy>=1.8.0 in /opt/conda/lib/python3.12/site-packages (from scikit-learn) (1.16.2)\n",
+ "Requirement already satisfied: joblib>=1.2.0 in /opt/conda/lib/python3.12/site-packages (from scikit-learn) (1.5.2)\n",
+ "Requirement already satisfied: threadpoolctl>=3.1.0 in /opt/conda/lib/python3.12/site-packages (from scikit-learn) (3.6.0)\n",
+ "Requirement already satisfied: matplotlib in /opt/conda/lib/python3.12/site-packages (3.10.7)\n",
+ "Requirement already satisfied: contourpy>=1.0.1 in /opt/conda/lib/python3.12/site-packages (from matplotlib) (1.3.3)\n",
+ "Requirement already satisfied: cycler>=0.10 in /opt/conda/lib/python3.12/site-packages (from matplotlib) (0.12.1)\n",
+ "Requirement already satisfied: fonttools>=4.22.0 in /opt/conda/lib/python3.12/site-packages (from matplotlib) (4.60.1)\n",
+ "Requirement already satisfied: kiwisolver>=1.3.1 in /opt/conda/lib/python3.12/site-packages (from matplotlib) (1.4.9)\n",
+ "Requirement already satisfied: numpy>=1.23 in /opt/conda/lib/python3.12/site-packages (from matplotlib) (2.3.4)\n",
+ "Requirement already satisfied: packaging>=20.0 in /opt/conda/lib/python3.12/site-packages (from matplotlib) (24.2)\n",
+ "Requirement already satisfied: pillow>=8 in /opt/conda/lib/python3.12/site-packages (from matplotlib) (12.0.0)\n",
+ "Requirement already satisfied: pyparsing>=3 in /opt/conda/lib/python3.12/site-packages (from matplotlib) (3.2.5)\n",
+ "Requirement already satisfied: python-dateutil>=2.7 in /opt/conda/lib/python3.12/site-packages (from matplotlib) (2.9.0.post0)\n",
+ "Requirement already satisfied: six>=1.5 in /opt/conda/lib/python3.12/site-packages (from python-dateutil>=2.7->matplotlib) (1.17.0)\n",
+ "Requirement already satisfied: pandas in /opt/conda/lib/python3.12/site-packages (2.3.3)\n",
+ "Requirement already satisfied: numpy>=1.26.0 in /opt/conda/lib/python3.12/site-packages (from pandas) (2.3.4)\n",
+ "Requirement already satisfied: python-dateutil>=2.8.2 in /opt/conda/lib/python3.12/site-packages (from pandas) (2.9.0.post0)\n",
+ "Requirement already satisfied: pytz>=2020.1 in /opt/conda/lib/python3.12/site-packages (from pandas) (2024.2)\n",
+ "Requirement already satisfied: tzdata>=2022.7 in /opt/conda/lib/python3.12/site-packages (from pandas) (2025.2)\n",
+ "Requirement already satisfied: six>=1.5 in /opt/conda/lib/python3.12/site-packages (from python-dateutil>=2.8.2->pandas) (1.17.0)\n",
+ "Requirement already satisfied: numpy in /opt/conda/lib/python3.12/site-packages (2.3.4)\n"
+ ]
+ }
+ ],
+ "source": [
+ "#!pip install scikit-learn==0.23.1\n",
+ "!pip install scikit-learn\n",
+ "!pip install matplotlib\n",
+ "!pip install pandas \n",
+ "!pip install numpy \n",
+ "%matplotlib inline"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "Let's first import required libraries:\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 2,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "import pandas as pd\n",
+ "import pylab as pl\n",
+ "import numpy as np\n",
+ "import scipy.optimize as opt\n",
+ "from sklearn import preprocessing\n",
+ "%matplotlib inline \n",
+ "import matplotlib.pyplot as plt"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "