Ridge_Lasso_ElasticNet.ipynb

{
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/Bady9898/R_Python_libraries/blob/main/Ridge_Lasso_ElasticNet.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "q-pkkmnDe8eQ"
      },
      "outputs": [],
      "source": [
        "import pandas as pd \n",
        "import numpy as np \n",
        "import matplotlib.pyplot as plt \n",
        "from sklearn import datasets \n",
        "from sklearn.model_selection import train_test_split \n",
        "from sklearn.linear_model import LinearRegression"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "pdLjRm4We8eW"
      },
      "outputs": [],
      "source": [
        "# Loading pre-defined Boston Dataset\n",
        "boston_dataset = datasets.load_boston()\n",
        "#print(boston_dataset.DESCR)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "NpM_6g_5e8eY"
      },
      "outputs": [],
      "source": [
        "#Load the data and divide into X and Y varaiable\n",
        "boston_pd = pd.DataFrame(boston_dataset.data) \n",
        "boston_pd.columns = boston_dataset.feature_names \n",
        "boston_pd_target = np.asarray(boston_dataset.target) \n",
        "boston_pd['House Price'] = pd.Series(boston_pd_target) \n",
        "\n",
        "# input \n",
        "X = boston_pd.iloc[:, :-1] \n",
        "\n",
        "#output \n",
        "Y = boston_pd.iloc[:, -1] \n",
        "\n",
        "print(boston_pd.head()) \n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "477OlC7Pe8ea"
      },
      "outputs": [],
      "source": [
        "X"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "cuVeQZLve8ec"
      },
      "outputs": [],
      "source": [
        "x_train, x_test, y_train, y_test = train_test_split(boston_pd.iloc[:, :-1],\n",
        "                                                    boston_pd.iloc[:, -1],\n",
        "                                                    test_size=0.25)\n",
        "\n",
        "(x_train.shape, y_train.shape,x_test.shape, y_test.shape)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "_r-F57bKe8ed"
      },
      "outputs": [],
      "source": [
        "# Apply multiple Linear Regression Model \n",
        "lreg = LinearRegression() \n",
        "lreg.fit(x_train, y_train) \n",
        "\n",
        "# Generate Prediction on test set \n",
        "lreg_y_pred = lreg.predict(x_test) \n",
        "\n",
        "# calculating Mean Squared Error (mse) \n",
        "mean_squared_error = np.mean((lreg_y_pred - y_test)**2) \n",
        "print(\"Mean squared Error on test set : \", mean_squared_error) \n",
        "\n",
        "# Putting together the coefficient and their corrsponding variable names \n",
        "lreg_coefficient = pd.DataFrame() \n",
        "lreg_coefficient[\"Columns\"] = x_train.columns \n",
        "lreg_coefficient['Coefficient Estimate'] = pd.Series(lreg.coef_) \n",
        "print(lreg_coefficient) \n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "ix2kfPERe8ee"
      },
      "outputs": [],
      "source": [
        "import seaborn as sns\n",
        "\n",
        "sns.barplot(x='Coefficient Estimate' , y='Columns', data=lreg_coefficient)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "UsdjUtFZe8ef"
      },
      "outputs": [],
      "source": [
        "# import ridge regression from sklearn library \n",
        "from sklearn.linear_model import Ridge \n",
        "\n",
        "# Train the model \n",
        "ridgeR = Ridge(alpha = 1) \n",
        "ridgeR.fit(x_train, y_train) \n",
        "y_pred = ridgeR.predict(x_test) \n",
        "\n",
        "# calculate mean square error \n",
        "mean_squared_error_ridge = np.mean((y_pred - y_test)**2) \n",
        "print(mean_squared_error_ridge) \n",
        "\n",
        "# get ridge coefficient and print them \n",
        "ridge_coefficient = pd.DataFrame() \n",
        "ridge_coefficient[\"Columns\"]= x_train.columns \n",
        "ridge_coefficient['Coefficient Estimate'] = pd.Series(ridgeR.coef_) \n",
        "print(ridge_coefficient) \n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "rbuz9THLe8eg"
      },
      "source": [
        "#### # import Lasso regression from sklearn library \n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "dr3_cMt2e8ej"
      },
      "outputs": [],
      "source": [
        "from sklearn.linear_model import Lasso \n",
        "\n",
        "# Train the model \n",
        "lasso = Lasso(alpha = 1) \n",
        "lasso.fit(x_train, y_train) \n",
        "y_pred1 = lasso.predict(x_test) \n",
        "\n",
        "# Calculate Mean Squared Error \n",
        "mean_squared_error = np.mean((y_pred1 - y_test)**2) \n",
        "print(\"Mean squared error on test set\", mean_squared_error) \n",
        "lasso_coeff = pd.DataFrame() \n",
        "lasso_coeff[\"Columns\"] = x_train.columns \n",
        "lasso_coeff['Coefficient Estimate'] = pd.Series(lasso.coef_) \n",
        "\n",
        "print(lasso_coeff) "
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "FGdAaTQoe8el"
      },
      "outputs": [],
      "source": [
        "# import model \n",
        "from sklearn.linear_model import ElasticNet \n",
        "\n",
        "# Train the model \n",
        "e_net = ElasticNet(alpha = .4,l1_ratio=.5) \n",
        "e_net.fit(x_train, y_train) \n",
        "\n",
        "# calculate the prediction and mean square error \n",
        "y_pred_elastic = e_net.predict(x_test) \n",
        "mean_squared_error = np.mean((y_pred_elastic - y_test)**2) \n",
        "print(\"Mean Squared Error on test set\", mean_squared_error) \n",
        "\n",
        "e_net_coeff = pd.DataFrame() \n",
        "e_net_coeff[\"Columns\"] = x_train.columns \n",
        "e_net_coeff['Coefficient Estimate'] = pd.Series(e_net.coef_) \n",
        "e_net_coeff \n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "OjZTe2b-e8en"
      },
      "outputs": [],
      "source": [
        ""
      ]
    }
  ],
  "metadata": {
    "kernelspec": {
      "display_name": "Python 3",
      "language": "python",
      "name": "python3"
    },
    "language_info": {
      "codemirror_mode": {
        "name": "ipython",
        "version": 3
      },
      "file_extension": ".py",
      "mimetype": "text/x-python",
      "name": "python",
      "nbconvert_exporter": "python",
      "pygments_lexer": "ipython3",
      "version": "3.7.4"
    },
    "colab": {
      "name": "Ridge_Lasso_ElasticNet.ipynb",
      "provenance": [],
      "include_colab_link": true
    }
  },
  "nbformat": 4,
  "nbformat_minor": 0
}