diff --git a/Tugas.Regression/Ananda dwi prasetyo-202310715065-Polynomial-Regression-Co2.ipynb b/Tugas.Regression/Ananda dwi prasetyo-202310715065-Polynomial-Regression-Co2.ipynb new file mode 100644 index 0000000..1112f74 --- /dev/null +++ b/Tugas.Regression/Ananda dwi prasetyo-202310715065-Polynomial-Regression-Co2.ipynb @@ -0,0 +1,532 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "

\n", + " \n", + " \"Skills\n", + " \n", + "

\n", + "\n", + "\n", + "# Polynomial Regression\n", + "\n", + "\n", + "Estimated time needed: **15** minutes\n", + " \n", + "\n", + "## Objectives\n", + "\n", + "After completing this lab you will be able to:\n", + "\n", + "* Use scikit-learn to implement Polynomial Regression\n", + "* Create a model, train it, test it and use the model\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "

Table of contents

\n", + "\n", + "
\n", + "
    \n", + "
  1. Downloading Data
    2. \n", + "
  2. Polynomial regression
    3. \n", + "
  3. Evaluation
    4. \n", + "
  4. Practice
    5. \n", + "
\n", + "
\n", + "
\n", + "
\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Importing Needed packages\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "import matplotlib.pyplot as plt\n", + "import pandas as pd\n", + "import pylab as pl\n", + "import numpy as np\n", + "%matplotlib inline\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "

Downloading Data

\n", + "To download the data, we will use !wget to download it from IBM Object Storage.\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "!wget -O FuelConsumption.csv https://cf-courses-data.s3.us.cloud-object-storage.appdomain.cloud/IBMDeveloperSkillsNetwork-ML0101EN-SkillsNetwork/labs/Module%202/data/FuelConsumptionCo2.csv" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "__Did you know?__ When it comes to Machine Learning, you will likely be working with large datasets. As a business, where can you host your data? IBM is offering a unique opportunity for businesses, with 10 Tb of IBM Cloud Object Storage: [Sign up now for free](https://www.ibm.com/us-en/cloud/object-storage?utm_source=skills_network&utm_content=in_lab_content_link&utm_id=Lab-IBMDeveloperSkillsNetwork-ML0101EN-SkillsNetwork)\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "## Understanding the Data\n", + "\n", + "### `FuelConsumption.csv`:\n", + "We have downloaded a fuel consumption dataset, **`FuelConsumption.csv`**, which contains model-specific fuel consumption ratings and estimated carbon dioxide emissions for new light-duty vehicles for retail sale in Canada. [Dataset source](http://open.canada.ca/data/en/dataset/98f1a129-f628-4ce4-b24d-6f16bf24dd64)\n", + "\n", + "- **MODELYEAR** e.g. 2014\n", + "- **MAKE** e.g. Acura\n", + "- **MODEL** e.g. ILX\n", + "- **VEHICLE CLASS** e.g. SUV\n", + "- **ENGINE SIZE** e.g. 4.7\n", + "- **CYLINDERS** e.g 6\n", + "- **TRANSMISSION** e.g. A6\n", + "- **FUEL CONSUMPTION in CITY(L/100 km)** e.g. 9.9\n", + "- **FUEL CONSUMPTION in HWY (L/100 km)** e.g. 8.9\n", + "- **FUEL CONSUMPTION COMB (L/100 km)** e.g. 9.2\n", + "- **CO2 EMISSIONS (g/km)** e.g. 182 --> low --> 0\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Reading the data in\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "df = pd.read_csv(\"FuelConsumption.csv\")\n", + "\n", + "# take a look at the dataset\n", + "df.head()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Let's select some features that we want to use for regression.\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "cdf = df[['ENGINESIZE','CYLINDERS','FUELCONSUMPTION_COMB','CO2EMISSIONS']]\n", + "cdf.head(9)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Let's plot Emission values with respect to Engine size:\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "plt.scatter(cdf.ENGINESIZE, cdf.CO2EMISSIONS, color='blue')\n", + "plt.xlabel(\"Engine size\")\n", + "plt.ylabel(\"Emission\")\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Creating train and test dataset\n", + "Train/Test Split involves splitting the dataset into training and testing sets respectively, which are mutually exclusive. After which, you train with the training set and test with the testing set.\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "msk = np.random.rand(len(df)) < 0.8\n", + "train = cdf[msk]\n", + "test = cdf[~msk]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "

Polynomial regression

\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Sometimes, the trend of data is not really linear, and looks curvy. In this case we can use Polynomial regression methods. In fact, many different regressions exist that can be used to fit whatever the dataset looks like, such as quadratic, cubic, and so on, and it can go on and on to infinite degrees.\n", + "\n", + "In essence, we can call all of these, polynomial regression, where the relationship between the independent variable x and the dependent variable y is modeled as an nth degree polynomial in x. Lets say you want to have a polynomial regression (let's make 2 degree polynomial):\n", + "\n", + "\n", + "$$y = b + \\theta_1 x + \\theta_2 x^2$$\n", + "\n", + "\n", + "\n", + "Now, the question is: how we can fit our data on this equation while we have only x values, such as __Engine Size__? \n", + "Well, we can create a few additional features: 1, $x$, and $x^2$.\n", + "\n", + "\n", + "\n", + "__PolynomialFeatures()__ function in Scikit-learn library, drives a new feature sets from the original feature set. That is, a matrix will be generated consisting of all polynomial combinations of the features with degree less than or equal to the specified degree. For example, lets say the original feature set has only one feature, _ENGINESIZE_. Now, if we select the degree of the polynomial to be 2, then it generates 3 features, degree=0, degree=1 and degree=2: \n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "from sklearn.preprocessing import PolynomialFeatures\n", + "from sklearn import linear_model\n", + "train_x = np.asanyarray(train[['ENGINESIZE']])\n", + "train_y = np.asanyarray(train[['CO2EMISSIONS']])\n", + "\n", + "test_x = np.asanyarray(test[['ENGINESIZE']])\n", + "test_y = np.asanyarray(test[['CO2EMISSIONS']])\n", + "\n", + "\n", + "poly = PolynomialFeatures(degree=2)\n", + "train_x_poly = poly.fit_transform(train_x)\n", + "train_x_poly" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**fit_transform** takes our x values, and output a list of our data raised from power of 0 to power of 2 (since we set the degree of our polynomial to 2). \n", + "\n", + "The equation and the sample example is displayed below. \n", + "\n", + "\n", + "$$\n", + "\\begin{bmatrix}\n", + " v_1\\\\\\\\\\\\\n", + " v_2\\\\\\\\\n", + " \\vdots\\\\\\\\\n", + " v_n\n", + "\\end{bmatrix}\\longrightarrow \\begin{bmatrix}\n", + " [ 1 & v_1 & v_1^2]\\\\\\\\\n", + " [ 1 & v_2 & v_2^2]\\\\\\\\\n", + " \\vdots & \\vdots & \\vdots\\\\\\\\\n", + " [ 1 & v_n & v_n^2]\n", + "\\end{bmatrix}\n", + "$$\n", + "\n", + "\n", + "\n", + "\n", + "$$\n", + "\\begin{bmatrix}\n", + " 2.\\\\\\\\\n", + " 2.4\\\\\\\\\n", + " 1.5\\\\\\\\\n", + " \\vdots\n", + "\\end{bmatrix} \\longrightarrow \\begin{bmatrix}\n", + " [ 1 & 2. & 4.]\\\\\\\\\n", + " [ 1 & 2.4 & 5.76]\\\\\\\\\n", + " [ 1 & 1.5 & 2.25]\\\\\\\\\n", + " \\vdots & \\vdots & \\vdots\\\\\\\\\n", + "\\end{bmatrix}\n", + "$$\n", + "\n", + "\n", + "\n", + "\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "It looks like feature sets for multiple linear regression analysis, right? Yes. It Does. \n", + "Indeed, Polynomial regression is a special case of linear regression, with the main idea of how do you select your features. Just consider replacing the $x$ with $x_1$, $x_1^2$ with $x_2$, and so on. Then the 2nd degree equation would be turn into:\n", + "\n", + "$$y = b + \\theta_1 x_1 + \\theta_2 x_2$$\n", + "\n", + "Now, we can deal with it as a 'linear regression' problem. Therefore, this polynomial regression is considered to be a special case of traditional multiple linear regression. So, you can use the same mechanism as linear regression to solve such problems. \n", + "\n", + "\n", + "\n", + "so we can use __LinearRegression()__ function to solve it:\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "clf = linear_model.LinearRegression()\n", + "train_y_ = clf.fit(train_x_poly, train_y)\n", + "# The coefficients\n", + "print ('Coefficients: ', clf.coef_)\n", + "print ('Intercept: ',clf.intercept_)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "As mentioned before, __Coefficient__ and __Intercept__ , are the parameters of the fit curvy line. \n", + "Given that it is a typical multiple linear regression, with 3 parameters, and knowing that the parameters are the intercept and coefficients of hyperplane, sklearn has estimated them from our new set of feature sets. Lets plot it:\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "plt.scatter(train.ENGINESIZE, train.CO2EMISSIONS, color='blue')\n", + "XX = np.arange(0.0, 10.0, 0.1)\n", + "yy = clf.intercept_[0]+ clf.coef_[0][1]*XX+ clf.coef_[0][2]*np.power(XX, 2)\n", + "plt.plot(XX, yy, '-r' )\n", + "plt.xlabel(\"Engine size\")\n", + "plt.ylabel(\"Emission\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "

Evaluation

\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "from sklearn.metrics import r2_score\n", + "\n", + "test_x_poly = poly.transform(test_x)\n", + "test_y_ = clf.predict(test_x_poly)\n", + "\n", + "print(\"Mean absolute error: %.2f\" % np.mean(np.absolute(test_y_ - test_y)))\n", + "print(\"Residual sum of squares (MSE): %.2f\" % np.mean((test_y_ - test_y) ** 2))\n", + "print(\"R2-score: %.2f\" % r2_score(test_y,test_y_ ) )" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "

Practice

\n", + "Try to use a polynomial regression with the dataset but this time with degree three (cubic). Does it result in better accuracy?\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# write your code here\n", + "import numpy as np\n", + "import pandas as pd\n", + "import matplotlib.pyplot as plt\n", + "from sklearn import linear_model\n", + "from sklearn.preprocessing import PolynomialFeatures\n", + "from sklearn.metrics import r2_score\n", + "from sklearn.model_selection import train_test_split\n", + "\n", + "df = pd.read_csv(\"FuelConsumptionCo2.csv\")\n", + "cdf = df[['ENGINESIZE', 'CO2EMISSIONS']]\n", + "\n", + "train, test = train_test_split(cdf, test_size=0.2, random_state=42)\n", + "train_x = np.asanyarray(train[['ENGINESIZE']])\n", + "train_y = np.asanyarray(train[['CO2EMISSIONS']])\n", + "test_x = np.asanyarray(test[['ENGINESIZE']])\n", + "test_y = np.asanyarray(test[['CO2EMISSIONS']])\n", + "\n", + "poly3 = PolynomialFeatures(degree=3)\n", + "train_x_poly3 = poly3.fit_transform(train_x)\n", + "\n", + "clf3 = linear_model.LinearRegression()\n", + "clf3.fit(train_x_poly3, train_y)\n", + "\n", + "print(\"Coefficients: \", clf3.coef_)\n", + "print(\"Intercept: \", clf3.intercept_)\n", + "\n", + "plt.scatter(train.ENGINESIZE, train.CO2EMISSIONS, color='blue')\n", + "XX = np.arange(0.0, 10.0, 0.1)\n", + "YY = (clf3.intercept_[0]\n", + " + clf3.coef_[0][1]*XX\n", + " + clf3.coef_[0][2]*np.power(XX, 2)\n", + " + clf3.coef_[0][3]*np.power(XX, 3))\n", + "plt.plot(XX, YY, '-r')\n", + "plt.xlabel(\"Engine size\")\n", + "plt.ylabel(\"Emission\")\n", + "plt.title(\"Polynomial Regression (Degree 3)\")\n", + "plt.show()\n", + "\n", + "test_x_poly3 = poly3.transform(test_x)\n", + "test_y3_ = clf3.predict(test_x_poly3)\n", + "\n", + "print(\"Mean absolute error: %.2f\" % np.mean(np.absolute(test_y3_ - test_y)))\n", + "print(\"Residual sum of squares (MSE): %.2f\" % np.mean((test_y3_ - test_y) ** 2))\n", + "print(\"R2-score: %.2f\" % r2_score(test_y, test_y3_))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "
Click here for the solution\n", + "\n", + "```python \n", + "poly3 = PolynomialFeatures(degree=3)\n", + "train_x_poly3 = poly3.fit_transform(train_x)\n", + "clf3 = linear_model.LinearRegression()\n", + "train_y3_ = clf3.fit(train_x_poly3, train_y)\n", + "\n", + "# The coefficients\n", + "print ('Coefficients: ', clf3.coef_)\n", + "print ('Intercept: ',clf3.intercept_)\n", + "plt.scatter(train.ENGINESIZE, train.CO2EMISSIONS, color='blue')\n", + "XX = np.arange(0.0, 10.0, 0.1)\n", + "yy = clf3.intercept_[0]+ clf3.coef_[0][1]*XX + clf3.coef_[0][2]*np.power(XX, 2) + clf3.coef_[0][3]*np.power(XX, 3)\n", + "plt.plot(XX, yy, '-r' )\n", + "plt.xlabel(\"Engine size\")\n", + "plt.ylabel(\"Emission\")\n", + "test_x_poly3 = poly3.transform(test_x)\n", + "test_y3_ = clf3.predict(test_x_poly3)\n", + "print(\"Mean absolute error: %.2f\" % np.mean(np.absolute(test_y3_ - test_y)))\n", + "print(\"Residual sum of squares (MSE): %.2f\" % np.mean((test_y3_ - test_y) ** 2))\n", + "print(\"R2-score: %.2f\" % r2_score(test_y,test_y3_ ) )\n", + "\n", + "```\n", + "\n", + "
\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "

Want to learn more?

\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", + "##

© IBM Corporation 2020. All rights reserved.

\n", + "\n", + "\n", + "\n", + "\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python", + "language": "python", + "name": "conda-env-python-py" + }, + "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.12" + }, + "prev_pub_hash": "4dc110debac287dfd374a575573c16e62a80a935b3bbe2b2f6d5a0598e6e33f6" + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/Tugas.Regression/Ananda dwi prasetyo-202310715065-multiple linear regression.ipynb b/Tugas.Regression/Ananda dwi prasetyo-202310715065-multiple linear regression.ipynb new file mode 100644 index 0000000..2f4ae67 --- /dev/null +++ b/Tugas.Regression/Ananda dwi prasetyo-202310715065-multiple linear regression.ipynb @@ -0,0 +1,448 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "

\n", + " \n", + " \"Skills\n", + " \n", + "

\n", + "\n", + "\n", + "# Multiple Linear Regression\n", + "\n", + "\n", + "Estimated time needed: **15** minutes\n", + " \n", + "\n", + "## Objectives\n", + "\n", + "After completing this lab you will be able to:\n", + "\n", + "* Use scikit-learn to implement Multiple Linear Regression\n", + "* Create a model, train it, test it and use the model\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "

Table of contents

\n", + "\n", + "
\n", + "
    \n", + "
  1. Understanding the Data
    2. \n", + "
  2. Reading the Data in
    3. \n", + "
  3. Multiple Regression Model
    4. \n", + "
  4. Prediction
    5. \n", + "
  5. Practice
    6. \n", + "
\n", + "
\n", + "
\n", + "
\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Importing Needed packages\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "import matplotlib.pyplot as plt\n", + "import pandas as pd\n", + "import pylab as pl\n", + "import numpy as np\n", + "%matplotlib inline" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Downloading Data\n", + "To download the data, we will use !wget to download it from IBM Object Storage.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--2025-10-20 06:45:18-- https://cf-courses-data.s3.us.cloud-object-storage.appdomain.cloud/IBMDeveloperSkillsNetwork-ML0101EN-SkillsNetwork/labs/Module%202/data/FuelConsumptionCo2.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, 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", + "HTTP request sent, awaiting response... 200 OK\n", + "Length: 72629 (71K) [text/csv]\n", + "Saving to: ‘FuelConsumption.csv’\n", + "\n", + "FuelConsumption.csv 100%[===================>] 70.93K --.-KB/s in 0.005s \n", + "\n", + "2025-10-20 06:45:19 (15.3 MB/s) - ‘FuelConsumption.csv’ saved [72629/72629]\n", + "\n" + ] + } + ], + "source": [ + "!wget -O FuelConsumption.csv https://cf-courses-data.s3.us.cloud-object-storage.appdomain.cloud/IBMDeveloperSkillsNetwork-ML0101EN-SkillsNetwork/labs/Module%202/data/FuelConsumptionCo2.csv" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "

Understanding the Data

\n", + "\n", + "### `FuelConsumption.csv`:\n", + "We have downloaded a fuel consumption dataset, **`FuelConsumption.csv`**, which contains model-specific fuel consumption ratings and estimated carbon dioxide emissions for new light-duty vehicles for retail sale in Canada. [Dataset source](http://open.canada.ca/data/en/dataset/98f1a129-f628-4ce4-b24d-6f16bf24dd64)\n", + "\n", + "- **MODELYEAR** e.g. 2014\n", + "- **MAKE** e.g. Acura\n", + "- **MODEL** e.g. ILX\n", + "- **VEHICLE CLASS** e.g. SUV\n", + "- **ENGINE SIZE** e.g. 4.7\n", + "- **CYLINDERS** e.g 6\n", + "- **TRANSMISSION** e.g. A6\n", + "- **FUELTYPE** e.g. z\n", + "- **FUEL CONSUMPTION in CITY(L/100 km)** e.g. 9.9\n", + "- **FUEL CONSUMPTION in HWY (L/100 km)** e.g. 8.9\n", + "- **FUEL CONSUMPTION COMB (L/100 km)** e.g. 9.2\n", + "- **CO2 EMISSIONS (g/km)** e.g. 182 --> low --> 0\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "

Reading the data in

\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "df = pd.read_csv(\"FuelConsumption.csv\")\n", + "\n", + "# take a look at the dataset\n", + "df.head()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Let's select some features that we want to use for regression.\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "cdf = df[['ENGINESIZE','CYLINDERS','FUELCONSUMPTION_CITY','FUELCONSUMPTION_HWY','FUELCONSUMPTION_COMB','CO2EMISSIONS']]\n", + "cdf.head(9)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Let's plot Emission values with respect to Engine size:\n" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "tags": [] + }, + "outputs": [ + { + "ename": "NameError", + "evalue": "name 'plt' is not defined", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mNameError\u001b[0m Traceback (most recent call last)", + "\u001b[0;32m/tmp/ipykernel_3917/181093676.py\u001b[0m in \u001b[0;36m\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mplt\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mscatter\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mcdf\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mENGINESIZE\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mcdf\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mCO2EMISSIONS\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mcolor\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m'blue'\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 2\u001b[0m \u001b[0mplt\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mxlabel\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"Engine size\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 3\u001b[0m \u001b[0mplt\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mylabel\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"Emission\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 4\u001b[0m \u001b[0mplt\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mshow\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;31mNameError\u001b[0m: name 'plt' is not defined" + ] + } + ], + "source": [ + "plt.scatter(cdf.ENGINESIZE, cdf.CO2EMISSIONS, color='blue')\n", + "plt.xlabel(\"Engine size\")\n", + "plt.ylabel(\"Emission\")\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Creating train and test dataset\n", + "Train/Test Split involves splitting the dataset into training and testing sets respectively, which are mutually exclusive. After which, you train with the training set and test with the testing set. \n", + "This will provide a more accurate evaluation on out-of-sample accuracy because the testing dataset is not part of the dataset that have been used to train the model. Therefore, it gives us a better understanding of how well our model generalizes on new data.\n", + "\n", + "We know the outcome of each data point in the testing dataset, making it great to test with! Since this data has not been used to train the model, the model has no knowledge of the outcome of these data points. So, in essence, it is truly an out-of-sample testing.\n", + "\n", + "Let's split our dataset into train and test sets. Around 80% of the entire dataset will be used for training and 20% for testing. We create a mask to select random rows using the __np.random.rand()__ function: \n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "msk = np.random.rand(len(df)) < 0.8\n", + "train = cdf[msk]\n", + "test = cdf[~msk]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Train data distribution\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "plt.scatter(train.ENGINESIZE, train.CO2EMISSIONS, color='blue')\n", + "plt.xlabel(\"Engine size\")\n", + "plt.ylabel(\"Emission\")\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "

Multiple Regression Model

\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "In reality, there are multiple variables that impact the co2emission. When more than one independent variable is present, the process is called multiple linear regression. An example of multiple linear regression is predicting co2emission using the features FUELCONSUMPTION_COMB, EngineSize and Cylinders of cars. The good thing here is that multiple linear regression model is the extension of the simple linear regression model.\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "from sklearn import linear_model\n", + "regr = linear_model.LinearRegression()\n", + "x = np.asanyarray(train[['ENGINESIZE','CYLINDERS','FUELCONSUMPTION_COMB']])\n", + "y = np.asanyarray(train[['CO2EMISSIONS']])\n", + "regr.fit (x, y)\n", + "# The coefficients\n", + "print ('Coefficients: ', regr.coef_)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "As mentioned before, __Coefficient__ and __Intercept__ are the parameters of the fitted line. \n", + "Given that it is a multiple linear regression model with 3 parameters and that the parameters are the intercept and coefficients of the hyperplane, sklearn can estimate them from our data. Scikit-learn uses plain Ordinary Least Squares method to solve this problem.\n", + "\n", + "#### Ordinary Least Squares (OLS)\n", + "OLS is a method for estimating the unknown parameters in a linear regression model. OLS chooses the parameters of a linear function of a set of explanatory variables by minimizing the sum of the squares of the differences between the target dependent variable and those predicted by the linear function. In other words, it tries to minimizes the sum of squared errors (SSE) or mean squared error (MSE) between the target variable (y) and our predicted output ($\\hat{y}$) over all samples in the dataset.\n", + "\n", + "OLS can find the best parameters using of the following methods:\n", + "* Solving the model parameters analytically using closed-form equations\n", + "* Using an optimization algorithm (Gradient Descent, Stochastic Gradient Descent, Newton’s Method, etc.)\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "

Prediction

\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "y_hat= regr.predict(test[['ENGINESIZE','CYLINDERS','FUELCONSUMPTION_COMB']])\n", + "x = np.asanyarray(test[['ENGINESIZE','CYLINDERS','FUELCONSUMPTION_COMB']])\n", + "y = np.asanyarray(test[['CO2EMISSIONS']])\n", + "print(\"Mean Squared Error (MSE) : %.2f\"\n", + " % np.mean((y_hat - y) ** 2))\n", + "\n", + "# Explained variance score: 1 is perfect prediction\n", + "print('Variance score: %.2f' % regr.score(x, y))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "__Explained variance regression score:__ \n", + "Let $\\hat{y}$ be the estimated target output, y the corresponding (correct) target output, and Var be the Variance (the square of the standard deviation). Then the explained variance is estimated as follows:\n", + "\n", + "$\\texttt{explainedVariance}(y, \\hat{y}) = 1 - \\frac{Var\\{ y - \\hat{y}\\}}{Var\\{y\\}}$ \n", + "The best possible score is 1.0, the lower values are worse.\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "

Practice

\n", + "Try to use a multiple linear regression with the same dataset, but this time use FUELCONSUMPTION_CITY and FUELCONSUMPTION_HWY instead of FUELCONSUMPTION_COMB. Does it result in better accuracy?\n" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Coefficients: [[11.23567565 7.0089373 5.59604353 3.81386072]]\n", + "Residual sum of squares: 511.51\n", + "Variance score: 0.88\n" + ] + } + ], + "source": [ + "import pandas as pd\n", + "import numpy as np\n", + "from sklearn import linear_model\n", + "from sklearn.model_selection import train_test_split\n", + "\n", + "df = pd.read_csv(\"FuelConsumptionCo2.csv\")\n", + "train, test = train_test_split(df, test_size=0.2, random_state=42)\n", + "\n", + "regr = linear_model.LinearRegression()\n", + "x_train = np.asanyarray(train[['ENGINESIZE', 'CYLINDERS', 'FUELCONSUMPTION_CITY', 'FUELCONSUMPTION_HWY']])\n", + "y_train = np.asanyarray(train[['CO2EMISSIONS']])\n", + "regr.fit(x_train, y_train)\n", + "print('Coefficients:', regr.coef_)\n", + "\n", + "x_test = np.asanyarray(test[['ENGINESIZE', 'CYLINDERS', 'FUELCONSUMPTION_CITY', 'FUELCONSUMPTION_HWY']])\n", + "y_test = np.asanyarray(test[['CO2EMISSIONS']])\n", + "y_pred = regr.predict(x_test)\n", + "\n", + "print(\"Residual sum of squares: %.2f\" % np.mean((y_pred - y_test) ** 2))\n", + "print(\"Variance score: %.2f\" % regr.score(x_test, y_test))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "
Click here for the solution\n", + "\n", + "```python\n", + "regr = linear_model.LinearRegression()\n", + "x = np.asanyarray(train[['ENGINESIZE','CYLINDERS','FUELCONSUMPTION_CITY','FUELCONSUMPTION_HWY']])\n", + "y = np.asanyarray(train[['CO2EMISSIONS']])\n", + "regr.fit (x, y)\n", + "print ('Coefficients: ', regr.coef_)\n", + "y_= regr.predict(test[['ENGINESIZE','CYLINDERS','FUELCONSUMPTION_CITY','FUELCONSUMPTION_HWY']])\n", + "x = np.asanyarray(test[['ENGINESIZE','CYLINDERS','FUELCONSUMPTION_CITY','FUELCONSUMPTION_HWY']])\n", + "y = np.asanyarray(test[['CO2EMISSIONS']])\n", + "print(\"Residual sum of squares: %.2f\"% np.mean((y_ - y) ** 2))\n", + "print('Variance score: %.2f' % regr.score(x, y))\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", + "##

© IBM Corporation 2020. All rights reserved.

\n", + " \n", + "\n" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python", + "language": "python", + "name": "conda-env-python-py" + }, + "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.12" + }, + "prev_pub_hash": "c1170d4cb1c9bbce7dbbef74b645fc6b265a5aaf4ce89c4ac861feed8769ed99" + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/Tugas.Regression/Ananda dwi prasetyo-202310715065-non linear regression.ipynb b/Tugas.Regression/Ananda dwi prasetyo-202310715065-non linear regression.ipynb new file mode 100644 index 0000000..4096660 --- /dev/null +++ b/Tugas.Regression/Ananda dwi prasetyo-202310715065-non linear regression.ipynb @@ -0,0 +1,911 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "

\n", + " \n", + " \"Skills\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": 35, + "metadata": {}, + "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": 36, + "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", + "##You can adjust the slope and intercept to verify the changes in the graph\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": 37, + "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", + "##You can adjust the slope and intercept to verify the changes in the graph\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": {}, + "source": [ + "### Quadratic\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "$$ Y = X^2 $$\n" + ] + }, + { + "cell_type": "code", + "execution_count": 38, + "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", + "##You can adjust the slope and intercept to verify the changes in the graph\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": 39, + "metadata": {}, + "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", + "##You can adjust the slope and intercept to verify the changes in the graph\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": 40, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/jupyterlab/conda/envs/python/lib/python3.7/site-packages/ipykernel_launcher.py:3: RuntimeWarning: invalid value encountered in log\n", + " This is separate from the ipykernel package so we can avoid doing imports until\n" + ] + }, + { + "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 = np.log(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": [ + "### Sigmoidal/Logistic\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "$$ Y = a + \\frac{b}{1+ c^{(X-d)}}$$\n" + ] + }, + { + "cell_type": "code", + "execution_count": 41, + "metadata": {}, + "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-4/(1+np.power(3, X-2))\n", + "\n", + "plt.plot(X,Y) \n", + "plt.ylabel('Dependent Variable')\n", + "plt.xlabel('Independent Variable')\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "# Non-Linear Regression example\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "For an example, we're going to try and fit a non-linear model to the datapoints corresponding to China's GDP from 1960 to 2014. We download a dataset with two columns, the first, a year between 1960 and 2014, the second, China's corresponding annual gross domestic income in US dollars for that year. \n" + ] + }, + { + "cell_type": "code", + "execution_count": 42, + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2025-10-20 07:48:43 URL:https://cf-courses-data.s3.us.cloud-object-storage.appdomain.cloud/IBMDeveloperSkillsNetwork-ML0101EN-SkillsNetwork/labs/Module%202/data/china_gdp.csv [1218/1218] -> \"china_gdp.csv\" [1]\n" + ] + }, + { + "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", + "
YearValue
019605.918412e+10
119614.955705e+10
219624.668518e+10
319635.009730e+10
419645.906225e+10
519656.970915e+10
619667.587943e+10
719677.205703e+10
819686.999350e+10
919697.871882e+10
\n", + "
" + ], + "text/plain": [ + " Year Value\n", + "0 1960 5.918412e+10\n", + "1 1961 4.955705e+10\n", + "2 1962 4.668518e+10\n", + "3 1963 5.009730e+10\n", + "4 1964 5.906225e+10\n", + "5 1965 6.970915e+10\n", + "6 1966 7.587943e+10\n", + "7 1967 7.205703e+10\n", + "8 1968 6.999350e+10\n", + "9 1969 7.871882e+10" + ] + }, + "execution_count": 42, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "import numpy as np\n", + "import pandas as pd\n", + "\n", + "#downloading dataset\n", + "!wget -nv -O china_gdp.csv https://cf-courses-data.s3.us.cloud-object-storage.appdomain.cloud/IBMDeveloperSkillsNetwork-ML0101EN-SkillsNetwork/labs/Module%202/data/china_gdp.csv\n", + " \n", + "df = pd.read_csv(\"china_gdp.csv\")\n", + "df.head(10)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "__Did you know?__ When it comes to Machine Learning, you will likely be working with large datasets. As a business, where can you host your data? IBM is offering a unique opportunity for businesses, with 10 Tb of IBM Cloud Object Storage: [Sign up now for free](http://cocl.us/ML0101EN-IBM-Offer-CC)\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Plotting the Dataset ###\n", + "This is what the datapoints look like. It kind of looks like an either logistic or exponential function. The growth starts off slow, then from 2005 on forward, the growth is very significant. And finally, it decelerates slightly in the 2010s.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 43, + "metadata": { + "tags": [] + }, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.figure(figsize=(8,5))\n", + "x_data, y_data = (df[\"Year\"].values, df[\"Value\"].values)\n", + "plt.plot(x_data, y_data, 'ro')\n", + "plt.ylabel('GDP')\n", + "plt.xlabel('Year')\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Choosing a model ###\n", + "\n", + "From an initial look at the plot, we determine that the logistic function could be a good approximation,\n", + "since it has the property of starting with a slow growth, increasing growth in the middle, and then decreasing again at the end; as illustrated below:\n" + ] + }, + { + "cell_type": "code", + "execution_count": 44, + "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", + "Y = 1.0 / (1.0 + 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": [ + "\n", + "\n", + "The formula for the logistic function is the following:\n", + "\n", + "$$ \\hat{Y} = \\frac1{1+e^{-\\beta_1(X-\\beta_2)}}$$\n", + "\n", + "$\\beta_1$: Controls the curve's steepness,\n", + "\n", + "$\\beta_2$: Slides the curve on the x-axis.\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Building The Model ###\n", + "Now, let's build our regression model and initialize its parameters. \n" + ] + }, + { + "cell_type": "code", + "execution_count": 45, + "metadata": {}, + "outputs": [], + "source": [ + "def sigmoid(x, Beta_1, Beta_2):\n", + " y = 1 / (1 + np.exp(-Beta_1*(x-Beta_2)))\n", + " return y" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Lets look at a sample sigmoid line that might fit with the data:\n" + ] + }, + { + "cell_type": "code", + "execution_count": 46, + "metadata": { + "tags": [] + }, + "outputs": [ + { + "data": { + "text/plain": [ + "[]" + ] + }, + "execution_count": 46, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "beta_1 = 0.10\n", + "beta_2 = 1990.0\n", + "\n", + "#logistic function\n", + "Y_pred = sigmoid(x_data, beta_1 , beta_2)\n", + "\n", + "#plot initial prediction against datapoints\n", + "plt.plot(x_data, Y_pred*15000000000000.)\n", + "plt.plot(x_data, y_data, 'ro')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Our task here is to find the best parameters for our model. Lets first normalize our x and y:\n" + ] + }, + { + "cell_type": "code", + "execution_count": 47, + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "# Lets normalize our data\n", + "xdata =x_data/max(x_data)\n", + "ydata =y_data/max(y_data)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### How we find the best parameters for our fit line?\n", + "we can use __curve_fit__ which uses non-linear least squares to fit our sigmoid function, to data. Optimize values for the parameters so that the sum of the squared residuals of sigmoid(xdata, *popt) - ydata is minimized.\n", + "\n", + "popt are our optimized parameters.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 48, + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " beta_1 = 690.451712, beta_2 = 0.997207\n" + ] + } + ], + "source": [ + "from scipy.optimize import curve_fit\n", + "popt, pcov = curve_fit(sigmoid, xdata, ydata)\n", + "#print the final parameters\n", + "print(\" beta_1 = %f, beta_2 = %f\" % (popt[0], popt[1]))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now we plot our resulting regression model.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 49, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "x = np.linspace(1960, 2015, 55)\n", + "x = x/max(x)\n", + "plt.figure(figsize=(8,5))\n", + "y = sigmoid(x, *popt)\n", + "plt.plot(xdata, ydata, 'ro', label='data')\n", + "plt.plot(x,y, linewidth=3.0, label='fit')\n", + "plt.legend(loc='best')\n", + "plt.ylabel('GDP')\n", + "plt.xlabel('Year')\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Practice\n", + "Can you calculate what is the accuracy of our model?\n" + ] + }, + { + "cell_type": "code", + "execution_count": 50, + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Mean Absolute Error (MAE): 0.03\n", + "Mean Squared Error (MSE): 0.00\n", + "Root Mean Squared Error (RMSE): 0.04\n", + "R2-score: 0.97\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "from sklearn.metrics import r2_score, mean_squared_error, mean_absolute_error\n", + "from scipy.optimize import curve_fit\n", + "\n", + "# Misal fungsi sigmoid\n", + "def sigmoid(x, beta1, beta2):\n", + " return 1 / (1 + np.exp(-beta1*(x-beta2)))\n", + "\n", + "# split data into train/test\n", + "msk = np.random.rand(len(df)) < 0.8\n", + "train_x = xdata[msk]\n", + "test_x = xdata[~msk]\n", + "train_y = ydata[msk]\n", + "test_y = ydata[~msk]\n", + "\n", + "# build the model using train set\n", + "popt, pcov = curve_fit(sigmoid, train_x, train_y)\n", + "\n", + "# predict using test set\n", + "y_hat = sigmoid(test_x, *popt)\n", + "\n", + "# evaluation metrics\n", + "mae = mean_absolute_error(test_y, y_hat)\n", + "mse = mean_squared_error(test_y, y_hat)\n", + "rmse = np.sqrt(mse)\n", + "r2 = r2_score(test_y, y_hat)\n", + "\n", + "print(\"Mean Absolute Error (MAE): %.2f\" % mae)\n", + "print(\"Mean Squared Error (MSE): %.2f\" % mse)\n", + "print(\"Root Mean Squared Error (RMSE): %.2f\" % rmse)\n", + "print(\"R2-score: %.2f\" % r2)\n", + "\n", + "# Optional: plot actual vs predicted\n", + "plt.scatter(test_x, test_y, label='Actual', color='blue')\n", + "plt.scatter(test_x, y_hat, label='Predicted', color='red')\n", + "plt.xlabel('X')\n", + "plt.ylabel('Y')\n", + "plt.title('Sigmoid Regression: Actual vs Predicted')\n", + "plt.legend()\n", + "plt.show()\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "
Click here for the solution\n", + "\n", + "```python \n", + "# split data into train/test\n", + "msk = np.random.rand(len(df)) < 0.8\n", + "train_x = xdata[msk]\n", + "test_x = xdata[~msk]\n", + "train_y = ydata[msk]\n", + "test_y = ydata[~msk]\n", + "\n", + "# build the model using train set\n", + "popt, pcov = curve_fit(sigmoid, train_x, train_y)\n", + "\n", + "# predict using test set\n", + "y_hat = sigmoid(test_x, *popt)\n", + "\n", + "# evaluation\n", + "print(\"Mean absolute error: %.2f\" % np.mean(np.absolute(y_hat - test_y)))\n", + "print(\"Residual sum of squares (MSE): %.2f\" % np.mean((y_hat - test_y) ** 2))\n", + "from sklearn.metrics import r2_score\n", + "print(\"R2-score: %.2f\" % r2_score(test_y,y_hat) )\n", + "\n", + "```\n", + "\n", + "
\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "

Want to learn more?

\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", + "##

© IBM Corporation 2020. All rights reserved.

\n", + "\n", + "\n", + "\n", + "\n", + "\n" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python", + "language": "python", + "name": "conda-env-python-py" + }, + "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.12" + }, + "prev_pub_hash": "f873d3177bf529d2d648c46bab1627042a257e5ec6ce42ca68028520459f817e" + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/Tugas.Regression/Ananda dwi prasetyo_202310715065-single linear regression.ipynb b/Tugas.Regression/Ananda dwi prasetyo_202310715065-single linear regression.ipynb new file mode 100644 index 0000000..d8ccc85 --- /dev/null +++ b/Tugas.Regression/Ananda dwi prasetyo_202310715065-single linear regression.ipynb @@ -0,0 +1,937 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "

\n", + " \n", + " \"Skills\n", + " \n", + "

\n", + "\n", + "\n", + "# Simple Linear Regression\n", + "\n", + "\n", + "Estimated time needed: **15** minutes\n", + " \n", + "\n", + "## Objectives\n", + "\n", + "After completing this lab you will be able to:\n", + "\n", + "* Use scikit-learn to implement simple Linear Regression\n", + "* Create a model, train it, test it and use the model\n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "tags": [] + }, + "source": [ + "### Importing Needed packages\n" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "import matplotlib.pyplot as plt\n", + "import pandas as pd\n", + "import pylab as pl\n", + "import numpy as np\n", + "%matplotlib inline" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Downloading Data\n", + "To download the data, we will use !wget to download it from IBM Object Storage.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--2025-10-20 04:38:57-- https://cf-courses-data.s3.us.cloud-object-storage.appdomain.cloud/IBMDeveloperSkillsNetwork-ML0101EN-SkillsNetwork/labs/Module%202/data/FuelConsumptionCo2.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, 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", + "HTTP request sent, awaiting response... 200 OK\n", + "Length: 72629 (71K) [text/csv]\n", + "Saving to: ‘FuelConsumption.csv’\n", + "\n", + "FuelConsumption.csv 100%[===================>] 70.93K --.-KB/s in 0.002s \n", + "\n", + "2025-10-20 04:38:57 (29.4 MB/s) - ‘FuelConsumption.csv’ saved [72629/72629]\n", + "\n" + ] + } + ], + "source": [ + "!wget -O FuelConsumption.csv https://cf-courses-data.s3.us.cloud-object-storage.appdomain.cloud/IBMDeveloperSkillsNetwork-ML0101EN-SkillsNetwork/labs/Module%202/data/FuelConsumptionCo2.csv" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "In case you're working **locally** uncomment the below line. \n" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "#!curl https://cf-courses-data.s3.us.cloud-object-storage.appdomain.cloud/IBMDeveloperSkillsNetwork-ML0101EN-SkillsNetwork/labs/Module%202/data/FuelConsumptionCo2.csv -o FuelConsumptionCo2.csv" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "## Understanding the Data\n", + "\n", + "### `FuelConsumption.csv`:\n", + "We have downloaded a fuel consumption dataset, **`FuelConsumption.csv`**, which contains model-specific fuel consumption ratings and estimated carbon dioxide emissions for new light-duty vehicles for retail sale in Canada. [Dataset source](http://open.canada.ca/data/en/dataset/98f1a129-f628-4ce4-b24d-6f16bf24dd64)\n", + "\n", + "- **MODELYEAR** e.g. 2014\n", + "- **MAKE** e.g. Acura\n", + "- **MODEL** e.g. ILX\n", + "- **VEHICLE CLASS** e.g. SUV\n", + "- **ENGINE SIZE** e.g. 4.7\n", + "- **CYLINDERS** e.g 6\n", + "- **TRANSMISSION** e.g. A6\n", + "- **FUEL CONSUMPTION in CITY(L/100 km)** e.g. 9.9\n", + "- **FUEL CONSUMPTION in HWY (L/100 km)** e.g. 8.9\n", + "- **FUEL CONSUMPTION COMB (L/100 km)** e.g. 9.2\n", + "- **CO2 EMISSIONS (g/km)** e.g. 182 --> low --> 0\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Reading the data in\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "df = pd.read_csv(\"FuelConsumption.csv\")\n", + "\n", + "# take a look at the dataset\n", + "df.head()\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "tags": [] + }, + "source": [ + "### Data Exploration\n", + "Let's first have a descriptive exploration on our data.\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# summarize the data\n", + "df.describe()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Let's select some features to explore more.\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "cdf = df[['ENGINESIZE','CYLINDERS','FUELCONSUMPTION_COMB','CO2EMISSIONS']]\n", + "cdf.head(9)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We can plot each of these features:\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "viz = cdf[['CYLINDERS','ENGINESIZE','CO2EMISSIONS','FUELCONSUMPTION_COMB']]\n", + "viz.hist()\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now, let's plot each of these features against the Emission, to see how linear their relationship is:\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "plt.scatter(cdf.FUELCONSUMPTION_COMB, cdf.CO2EMISSIONS, color='blue')\n", + "plt.xlabel(\"FUELCONSUMPTION_COMB\")\n", + "plt.ylabel(\"Emission\")\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "plt.scatter(cdf.ENGINESIZE, cdf.CO2EMISSIONS, color='blue')\n", + "plt.xlabel(\"Engine size\")\n", + "plt.ylabel(\"Emission\")\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "tags": [] + }, + "source": [ + "## Practice\n", + "Plot __CYLINDER__ vs the Emission, to see how linear is their relationship is:\n" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": { + "tags": [] + }, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "\n", + "\n", + "plt.scatter(cdf.CYLINDERS, cdf.CO2EMISSIONS, color='red')\n", + "plt.xlabel(\"Cylinders\")\n", + "plt.ylabel(\"Emission\")\n", + "plt.show()\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "
Click here for the solution\n", + "\n", + "```python \n", + "plt.scatter(cdf.CYLINDERS, cdf.CO2EMISSIONS, color='blue')\n", + "plt.xlabel(\"Cylinders\")\n", + "plt.ylabel(\"Emission\")\n", + "plt.show()\n", + "\n", + "```\n", + "\n", + "
\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Creating train and test dataset\n", + "Train/Test Split involves splitting the dataset into training and testing sets that are mutually exclusive. After which, you train with the training set and test with the testing set. \n", + "This will provide a more accurate evaluation on out-of-sample accuracy because the testing dataset is not part of the dataset that have been used to train the model. Therefore, it gives us a better understanding of how well our model generalizes on new data.\n", + "\n", + "This means that we know the outcome of each data point in the testing dataset, making it great to test with! Since this data has not been used to train the model, the model has no knowledge of the outcome of these data points. So, in essence, it is truly an out-of-sample testing.\n", + "\n", + "Let's split our dataset into train and test sets. 80% of the entire dataset will be used for training and 20% for testing. We create a mask to select random rows using __np.random.rand()__ function: \n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "msk = np.random.rand(len(df)) < 0.8\n", + "train = cdf[msk]\n", + "test = cdf[~msk]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Simple Regression Model\n", + "Linear Regression fits a linear model with coefficients B = (B1, ..., Bn) to minimize the 'residual sum of squares' between the actual value y in the dataset, and the predicted value yhat using linear approximation. \n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Train data distribution\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "plt.scatter(train.ENGINESIZE, train.CO2EMISSIONS, color='blue')\n", + "plt.xlabel(\"Engine size\")\n", + "plt.ylabel(\"Emission\")\n", + "plt.show() " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Modeling\n", + "Using sklearn package to model data.\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "from sklearn import linear_model\n", + "regr = linear_model.LinearRegression()\n", + "train_x = np.asanyarray(train[['ENGINESIZE']])\n", + "train_y = np.asanyarray(train[['CO2EMISSIONS']])\n", + "regr.fit(train_x, train_y)\n", + "# The coefficients\n", + "print ('Coefficients: ', regr.coef_)\n", + "print ('Intercept: ',regr.intercept_)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "As mentioned before, __Coefficient__ and __Intercept__ in the simple linear regression, are the parameters of the fit line. \n", + "Given that it is a simple linear regression, with only 2 parameters, and knowing that the parameters are the intercept and slope of the line, sklearn can estimate them directly from our data. \n", + "Notice that all of the data must be available to traverse and calculate the parameters.\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Plot outputs\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We can plot the fit line over the data:\n" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [ + { + "ename": "NameError", + "evalue": "name 'train' is not defined", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mNameError\u001b[0m Traceback (most recent call last)", + "\u001b[0;32m/tmp/ipykernel_68/94242891.py\u001b[0m in \u001b[0;36m\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mplt\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mscatter\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtrain\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mCYLINDERS\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtrain\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mCO2EMISSIONS\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mcolor\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m'blue'\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 2\u001b[0m \u001b[0mplt\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mplot\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtrain_x\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mregr\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcoef_\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0mtrain_x\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0mregr\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mintercept_\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'-r'\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 3\u001b[0m \u001b[0mplt\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mxlabel\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"Cylinders\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 4\u001b[0m \u001b[0mplt\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mylabel\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"Emission\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;31mNameError\u001b[0m: name 'train' is not defined" + ] + } + ], + "source": [ + "plt.scatter(train.CYLINDERS, train.CO2EMISSIONS, color='blue')\n", + "plt.plot(train_x, regr.coef_[0][0]*train_x + regr.intercept_[0], '-r')\n", + "plt.xlabel(\"Cylinders\")\n", + "plt.ylabel(\"Emission\")" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "tags": [] + }, + "source": [ + "#### Evaluation\n", + "We compare the actual values and predicted values to calculate the accuracy of a regression model. Evaluation metrics provide a key role in the development of a model, as it provides insight to areas that require improvement.\n", + "\n", + "There are different model evaluation metrics, lets use MSE here to calculate the accuracy of our model based on the test set: \n", + "* Mean Absolute Error: It is the mean of the absolute value of the errors. This is the easiest of the metrics to understand since it’s just average error.\n", + "\n", + "* Mean Squared Error (MSE): Mean Squared Error (MSE) is the mean of the squared error. It’s more popular than Mean Absolute Error because the focus is geared more towards large errors. This is due to the squared term exponentially increasing larger errors in comparison to smaller ones.\n", + "\n", + "* Root Mean Squared Error (RMSE). \n", + "\n", + "* R-squared is not an error, but rather a popular metric to measure the performance of your regression model. It represents how close the data points are to the fitted regression line. The higher the R-squared value, the better the model fits your data. The best possible score is 1.0 and it can be negative (because the model can be arbitrarily worse).\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "from sklearn.metrics import r2_score\n", + "\n", + "test_x = np.asanyarray(test[['ENGINESIZE']])\n", + "test_y = np.asanyarray(test[['CO2EMISSIONS']])\n", + "test_y_ = regr.predict(test_x)\n", + "\n", + "print(\"Mean absolute error: %.2f\" % np.mean(np.absolute(test_y_ - test_y)))\n", + "print(\"Residual sum of squares (MSE): %.2f\" % np.mean((test_y_ - test_y) ** 2))\n", + "print(\"R2-score: %.2f\" % r2_score(test_y , test_y_) )" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Exercise\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Lets see what the evaluation metrics are if we trained a regression model using the `FUELCONSUMPTION_COMB` feature.\n", + "\n", + "Start by selecting `FUELCONSUMPTION_COMB` as the train_x data from the `train` dataframe, then select `FUELCONSUMPTION_COMB` as the test_x data from the `test` dataframe\n" + ] + }, + { + "cell_type": "code", + "execution_count": 32, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Coefficients: [[16.14931961]]\n", + "Intercept: [68.73325706]\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "msk = np.random.rand(len(df)) < 0.8\n", + "train = cdf[msk]\n", + "test = cdf[~msk]\n", + "\n", + "plt.scatter(train.FUELCONSUMPTION_COMB, train.CO2EMISSIONS, color='blue')\n", + "plt.xlabel(\"FUELCONSUMPTION_COMB\")\n", + "plt.ylabel(\"Emission\")\n", + "plt.show() \n", + "\n", + "from sklearn import linear_model\n", + "regr = linear_model.LinearRegression()\n", + "train_x = np.asanyarray(train[['FUELCONSUMPTION_COMB']])\n", + "train_y = np.asanyarray(train[['CO2EMISSIONS']])\n", + "regr.fit(train_x, train_y)\n", + "# The coefficients\n", + "print ('Coefficients: ', regr.coef_)\n", + "print ('Intercept: ',regr.intercept_)\n", + "\n", + "plt.scatter(train.FUELCONSUMPTION_COMB, train.CO2EMISSIONS, color='blue')\n", + "plt.plot(train_x, regr.coef_[0][0]*train_x + regr.intercept_[0], '-r')\n", + "plt.xlabel(\"FUELCONSUMPTION_COMB\")\n", + "plt.ylabel(\"Emission\")\n", + "\n", + "train_x = train[[\"FUELCONSUMPTION_COMB\"]]\n", + "test_x = test[[\"FUELCONSUMPTION_COMB\"]]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "
Click here for the solution\n", + "\n", + "```python \n", + "train_x = train[[\"FUELCONSUMPTION_COMB\"]]\n", + "\n", + "test_x = test[[\"FUELCONSUMPTION_COMB\"]]\n", + "\n", + "```\n", + "\n", + "
\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now train a Linear Regression Model using the `train_x` you created and the `train_y` created previously\n" + ] + }, + { + "cell_type": "code", + "execution_count": 33, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Coefficients: [[16.14931961]]\n", + "Intercept: [68.73325706]\n" + ] + } + ], + "source": [ + "from sklearn import linear_model\n", + "regr = linear_model.LinearRegression()\n", + "train_x = np.asanyarray(train[['FUELCONSUMPTION_COMB']])\n", + "train_y = np.asanyarray(train[['CO2EMISSIONS']])\n", + "regr.fit(train_x, train_y)\n", + "# The coefficients\n", + "print ('Coefficients: ', regr.coef_)\n", + "print ('Intercept: ',regr.intercept_)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "
Click here for the solution\n", + "\n", + "```python \n", + "regr = linear_model.LinearRegression()\n", + "\n", + "regr.fit(train_x, train_y)\n", + "\n", + "```\n", + "\n", + "
\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Find the predictions using the model's `predict` function and the `test_x` data\n" + ] + }, + { + "cell_type": "code", + "execution_count": 35, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[[206.00247373]\n", + " [247.99070471]\n", + " [230.22645314]\n", + " [256.06536452]\n", + " [317.43277903]\n", + " [218.92192942]\n", + " [202.77260981]\n", + " [204.38754177]\n", + " [304.51332334]\n", + " [356.19114609]\n", + " [272.21468413]\n", + " [277.05948001]\n", + " [235.07124903]\n", + " [335.1970306 ]\n", + " [204.38754177]\n", + " [176.93369844]\n", + " [230.22645314]\n", + " [196.31288197]\n", + " [265.75495628]\n", + " [273.82961609]\n", + " [306.1282553 ]\n", + " [291.59386766]\n", + " [306.1282553 ]\n", + " [291.59386766]\n", + " [215.6920655 ]\n", + " [272.21468413]\n", + " [206.00247373]\n", + " [201.15767785]\n", + " [228.61152118]\n", + " [251.22056863]\n", + " [336.81196256]\n", + " [306.1282553 ]\n", + " [275.44454805]\n", + " [252.8355006 ]\n", + " [259.29522844]\n", + " [325.50743883]\n", + " [335.1970306 ]\n", + " [335.1970306 ]\n", + " [415.94362864]\n", + " [359.42101001]\n", + " [196.31288197]\n", + " [291.59386766]\n", + " [214.07713354]\n", + " [231.8413851 ]\n", + " [230.22645314]\n", + " [244.76084079]\n", + " [340.04182648]\n", + " [226.99658922]\n", + " [230.22645314]\n", + " [249.60563667]\n", + " [285.13413981]\n", + " [307.74318726]\n", + " [207.61740569]\n", + " [210.84726961]\n", + " [194.69795001]\n", + " [178.5486304 ]\n", + " [440.16760805]\n", + " [364.26580589]\n", + " [223.7667253 ]\n", + " [260.9101604 ]\n", + " [270.59975216]\n", + " [325.50743883]\n", + " [267.36988824]\n", + " [335.1970306 ]\n", + " [304.51332334]\n", + " [359.42101001]\n", + " [191.46808608]\n", + " [181.77849432]\n", + " [193.08301804]\n", + " [231.8413851 ]\n", + " [199.54274589]\n", + " [239.91604491]\n", + " [273.82961609]\n", + " [259.29522844]\n", + " [249.60563667]\n", + " [335.1970306 ]\n", + " [433.70788021]\n", + " [372.3404657 ]\n", + " [373.95539766]\n", + " [259.29522844]\n", + " [341.65675844]\n", + " [278.67441197]\n", + " [215.6920655 ]\n", + " [425.6332204 ]\n", + " [365.88073785]\n", + " [185.00835824]\n", + " [180.16356236]\n", + " [254.45043256]\n", + " [223.7667253 ]\n", + " [193.08301804]\n", + " [254.45043256]\n", + " [247.99070471]\n", + " [256.06536452]\n", + " [191.46808608]\n", + " [283.51920785]\n", + " [361.03594197]\n", + " [268.9848202 ]\n", + " [351.34635021]\n", + " [283.51920785]\n", + " [280.28934393]\n", + " [246.37577275]\n", + " [220.53686138]\n", + " [228.61152118]\n", + " [323.89250687]\n", + " [220.53686138]\n", + " [247.99070471]\n", + " [275.44454805]\n", + " [285.13413981]\n", + " [204.38754177]\n", + " [223.7667253 ]\n", + " [191.46808608]\n", + " [252.8355006 ]\n", + " [259.29522844]\n", + " [214.07713354]\n", + " [215.6920655 ]\n", + " [317.43277903]\n", + " [414.32869668]\n", + " [236.68618099]\n", + " [246.37577275]\n", + " [225.38165726]\n", + " [225.38165726]\n", + " [246.37577275]\n", + " [275.44454805]\n", + " [233.45631707]\n", + " [265.75495628]\n", + " [252.8355006 ]\n", + " [170.47397059]\n", + " [327.12237079]\n", + " [280.28934393]\n", + " [197.92781393]\n", + " [207.61740569]\n", + " [188.23822216]\n", + " [180.16356236]\n", + " [225.38165726]\n", + " [223.7667253 ]\n", + " [197.92781393]\n", + " [238.30111295]\n", + " [315.81784707]\n", + " [217.30699746]\n", + " [254.45043256]\n", + " [280.28934393]\n", + " [256.06536452]\n", + " [257.68029648]\n", + " [277.05948001]\n", + " [277.05948001]\n", + " [323.89250687]\n", + " [264.14002432]\n", + " [257.68029648]\n", + " [214.07713354]\n", + " [322.27757491]\n", + " [194.69795001]\n", + " [194.69795001]\n", + " [202.77260981]\n", + " [202.77260981]\n", + " [202.77260981]\n", + " [202.77260981]\n", + " [256.06536452]\n", + " [207.61740569]\n", + " [215.6920655 ]\n", + " [233.45631707]\n", + " [246.37577275]\n", + " [210.84726961]\n", + " [238.30111295]\n", + " [246.37577275]\n", + " [246.37577275]\n", + " [231.8413851 ]\n", + " [294.82373158]\n", + " [260.9101604 ]\n", + " [228.61152118]\n", + " [236.68618099]\n", + " [236.68618099]\n", + " [289.97893569]\n", + " [254.45043256]\n", + " [275.44454805]\n", + " [277.05948001]\n", + " [317.43277903]\n", + " [356.19114609]\n", + " [252.8355006 ]\n", + " [327.12237079]\n", + " [204.38754177]\n", + " [197.92781393]\n", + " [206.00247373]\n", + " [222.15179334]\n", + " [225.38165726]\n", + " [194.69795001]\n", + " [206.00247373]\n", + " [186.6232902 ]\n", + " [235.07124903]\n", + " [249.60563667]\n", + " [260.9101604 ]\n", + " [259.29522844]\n", + " [183.39342628]\n", + " [223.7667253 ]\n", + " [186.6232902 ]\n", + " [214.07713354]\n", + " [180.16356236]\n", + " [254.45043256]\n", + " [254.45043256]]\n" + ] + } + ], + "source": [ + "predictions = regr.predict(test_x)\n", + "print(predictions)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "
Click here for the solution\n", + "\n", + "```python \n", + "predictions = regr.predict(test_x)\n", + "\n", + "```\n", + "\n", + "
\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Finally use the `predictions` and the `test_y` data and find the Mean Absolute Error value using the `np.absolute` and `np.mean` function like done previously\n" + ] + }, + { + "cell_type": "code", + "execution_count": 44, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Mean Absolute Error: 20.31\n" + ] + } + ], + "source": [ + "test_y = np.asanyarray(test[['CO2EMISSIONS']])\n", + "print(\"Mean Absolute Error: %.2f\" % np.mean(np.absolute(predictions - test_y)))" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "tags": [] + }, + "source": [ + "
Click here for the solution\n", + "\n", + "```python \n", + "print(\"Mean Absolute Error: %.2f\" % np.mean(np.absolute(predictions - test_y)))\n", + "\n", + "```\n", + "\n", + "
\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We can see that the MAE is much worse when we train using `ENGINESIZE` than `FUELCONSUMPTION_COMB`\n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "jp-MarkdownHeadingCollapsed": true, + "tags": [] + }, + "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", + "Azim Hirjani\n", + "\n", + "##

© IBM Corporation. All rights reserved.

\n", + "\n", + "\n", + "\n", + "\n" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python", + "language": "python", + "name": "conda-env-python-py" + }, + "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.12" + }, + "prev_pub_hash": "20d6dc1d9e74df451be22381c972d7921c93657bea402a00c749dca52bb85996" + }, + "nbformat": 4, + "nbformat_minor": 4 +}