From 17f991135c85d02cc66cd384ac282bc9429111b9 Mon Sep 17 00:00:00 2001 From: Winston Robson Date: Sat, 13 Jun 2020 17:56:49 -0700 Subject: [PATCH] Add lasso_and_ridge_regression.ipynb | init draft --- README.md | 1 + lasso_and_ridge_regression.ipynb | 506 +++++++++++++++++++++++++++++++ 2 files changed, 507 insertions(+) create mode 100644 lasso_and_ridge_regression.ipynb diff --git a/README.md b/README.md index 1343a7f..60d22c0 100644 --- a/README.md +++ b/README.md @@ -4,3 +4,4 @@ Algorithm | Notebook --- | --- Linear Regression (OLS) | [linear_regression.ipynb](linear_regression.ipynb) Distributed Linear Regression (OLS) | [distributed_linear_regression.ipynb](distributed/distributed_linear_regression.ipynb) +Linear Regression with Lasso or Ridge Regularization | [lasso_and_ridge_regression.ipynb](lasso_and_ridge_regression.ipynb) diff --git a/lasso_and_ridge_regression.ipynb b/lasso_and_ridge_regression.ipynb new file mode 100644 index 0000000..8375c83 --- /dev/null +++ b/lasso_and_ridge_regression.ipynb @@ -0,0 +1,506 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": { + "colab_type": "text", + "id": "XaDpeOh_coGf" + }, + "source": [ + "# Linear Regression with Lasso or Ridge Regularization\n", + "\n", + "Ridge and Lasso regression are some of the simple techniques to reduce model complexity and prevent over-fitting which may result from simple linear regression.\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "colab_type": "text", + "id": "gTp_2yZecoGm" + }, + "source": [ + "## Data" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "colab": {}, + "colab_type": "code", + "id": "qu9PGtG3coGn" + }, + "outputs": [], + "source": [ + "from sklearn.datasets import load_boston\n", + "# load Boston dataset\n", + "boston = load_boston()" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "# print(boston.DESCR)" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "import cudf\n", + "\n", + "df = cudf.DataFrame(data=list(boston.data), columns=boston.feature_names)\n", + "\n", + "df['MEDV'] = boston.target\n", + "\n", + "# df.tail()" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "# corr = df.to_pandas().corr()\n", + "# corr.style.background_gradient(cmap='coolwarm')" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "X = df[['RM', 'AGE', 'TAX']]\n", + "y = df.MEDV" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "from cuml.preprocessing.model_selection import train_test_split" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "X_train, X_test, y_train, y_test = train_test_split(X, y, train_size=0.8)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Lasso Regularization" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Lasso extends LinearRegression by providing L1 regularization on the coefficients when predicting response y with a linear combination of the predictors in X. It can zero some of the coefficients for feature selection and improves the conditioning of the problem. \n", + "\n", + "cuML's Lasso can take array-like objects, either in host as NumPy arrays or in device (as Numba or `__cuda_array_interface__` compliant), in addition to cuDF objects. It uses coordinate descent to fit a linear model." + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [], + "source": [ + "from cuml.linear_model import Lasso" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [], + "source": [ + "# run the cuml ridge regression model to fit the training dataset. Eig is the faster algorithm, but svd is more accurate \n", + "ls = Lasso(\n", + " alpha=1.0,\n", + " fit_intercept=True,\n", + " normalize=False,\n", + " max_iter=1000,\n", + " tol=0.001,\n", + " selection='cyclic',\n", + " handle=None,\n", + " output_type=None\n", + " )" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Lasso(alpha=1.0, fit_intercept=True, normalize=False, max_iter=1000, tol=0.001, selection='cyclic', handle=, output_type='input')" + ] + }, + "execution_count": 10, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "ls.fit(X_train, y_train)" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "CPU times: user 1.36 ms, sys: 743 µs, total: 2.1 ms\n", + "Wall time: 1.42 ms\n" + ] + } + ], + "source": [ + "%%time\n", + "# calculate the mean squared error of the testing dataset using the cuml ridge regression model\n", + "preds = ls.predict(X_test)" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "CPU times: user 4.1 ms, sys: 0 ns, total: 4.1 ms\n", + "Wall time: 3.23 ms\n" + ] + } + ], + "source": [ + "%%time\n", + "# calculate the mean squared error of the testing dataset using the cuml ridge regression model\n", + "preds = ls.predict(X_test)" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [], + "source": [ + "from cuml.metrics import mean_squared_error" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [], + "source": [ + "error = mean_squared_error(y_test, preds)" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "29.796427316935755\n" + ] + } + ], + "source": [ + "print(error)" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "import matplotlib.pyplot as plt\n", + "\n", + "# scatter actual and predicted results\n", + "plt.scatter(y_test.to_pandas(), preds.to_pandas())\n", + "\n", + "# label graph\n", + "plt.xlabel(\"Actual Prices: $Y_i$\")\n", + "plt.ylabel(\"Predicted prices: $\\hat{Y}_i$\")\n", + "plt.title(\"Prices vs Predicted prices: $Y_i$ vs $\\hat{Y}_i$\")\n", + "\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "markdown", + "metadata": { + "colab_type": "text", + "id": "Nd8dvjoKcoGr" + }, + "source": [ + "# Ridge Regression" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Ridge Regularization \n", + "Ridge extends LinearRegression by providing L2 regularization on the coefficients when predicting response y with a linear combination of the predictors in X. It can reduce the variance of the predictors, and improves the conditioning of the problem.\n", + "\n", + "The Ridge Regression function implemented in the cuml library allows the user to change the fit_intercept, normalize, solver and alpha parameters. Here is a brief on RAPIDS' Ridge Regression's parameters:\n", + "1. `alpha`: float or double. Regularization strength - must be a positive float. Larger values specify stronger regularization. Array input will be supported later.\n", + "1. `solver`: ‘eig’ or ‘svd’ or ‘cd’ (default = ‘eig’). Eig uses a eigendecomposition of the covariance matrix, and is much faster. SVD is slower, but is guaranteed to be stable. CD or Coordinate Descent is very fast and is suitable for large problems.\n", + "1. `fit_intercept`: boolean (default = True). If True, Ridge tries to correct for the global mean of y. If False, the model expects that you have centered the data.\n", + "1. `normalize`: boolean (default = False). If True, the predictors in X will be normalized by dividing by it’s L2 norm. If False, no scaling will be done.\n", + "\n", + "The methods that can be used with the Ridge Regression are:\n", + "1. `fit`: Fit the model with X and y.\n", + "1. `get_params`: Sklearn style return parameter state\n", + "1. `predict`: Predicts the y for X.\n", + "1. `set_params`: Sklearn style set parameter state to dictionary of params.\n", + "\n", + "The model accepts only numpy arrays or cudf dataframes as the input. \n", + "- In order to convert your dataset to cudf format please read the cudf [documentation](https://rapidsai.github.io/projects/cudf/en/latest/). \n", + "- It is important to understand that the 'svd' solver will run slower than the 'eig' solver however, the 'svd' solver is more stable and robust. \n", + " - Therefore, we would recomend that you use the 'eig' solver when a slight error is acceptable. \n", + " - For additional information please refer to the [documentation](https://rapidsai.github.io/projects/cuml/en/latest/index.html)" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [], + "source": [ + "from cuml.linear_model import Ridge" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 51 + }, + "colab_type": "code", + "id": "55fhclfXcoG9", + "outputId": "09e9ac9d-d5ce-4370-c16e-d959cc6bf200", + "scrolled": true + }, + "outputs": [], + "source": [ + "# run the cuml ridge regression model to fit the training dataset. Eig is the faster algorithm, but svd is more accurate \n", + "ridge = Ridge(fit_intercept=False,\n", + " normalize=True,\n", + " solver='eig', \n", + " alpha=0.1)" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Ridge(alpha=0.1, solver='eig', fit_intercept=False, normalize=True, handle=, output_type='cudf')" + ] + }, + "execution_count": 19, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "ridge.fit(X_train, y_train)" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 51 + }, + "colab_type": "code", + "id": "VH2p-JmicoHB", + "outputId": "8a061986-ca73-4d4b-853b-9d304a2cb06a" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "CPU times: user 3.96 ms, sys: 0 ns, total: 3.96 ms\n", + "Wall time: 2.86 ms\n" + ] + } + ], + "source": [ + "%%time\n", + "# calculate the mean squared error of the testing dataset using the cuml ridge regression model\n", + "preds = ridge.predict(X_test)" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": {}, + "outputs": [], + "source": [ + "from cuml.metrics import mean_squared_error" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": {}, + "outputs": [], + "source": [ + "error = mean_squared_error(y_test, preds)" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 85 + }, + "colab_type": "code", + "id": "Z5pcDGqAcoHJ", + "outputId": "88bfba52-2fb6-4594-eafe-c2816cba2094" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "31.040458246536684\n" + ] + } + ], + "source": [ + "print(error)" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "import matplotlib.pyplot as plt\n", + "\n", + "# scatter actual and predicted results\n", + "plt.scatter(y_test.to_pandas(), preds.to_pandas())\n", + "\n", + "# label graph\n", + "plt.xlabel(\"Actual Prices: $Y_i$\")\n", + "plt.ylabel(\"Predicted prices: $\\hat{Y}_i$\")\n", + "plt.title(\"Prices vs Predicted prices: $Y_i$ vs $\\hat{Y}_i$\")\n", + "\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "accelerator": "GPU", + "colab": { + "name": "ridge_regression_demo.ipynb", + "provenance": [], + "version": "0.3.2" + }, + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.7.7" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +}