linear_regression_SGD.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Linear Regression"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### TASK 1: Data Analysis and Data Cleaning"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "import numpy as np\n",
    "import matplotlib.mlab as mlab\n",
    "import matplotlib.pyplot as plt\n",
    "import scipy.stats\n",
    "from sklearn.model_selection import train_test_split\n",
    "from sklearn import preprocessing\n",
    "import statistics"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Load the dataset into memory"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "bweight_data = pd.read_csv(\"baby-weights-dataset.csv\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Computing mean, stdev, min, max, 25% percentile, median and 75% percentile of the dataset (BWEIGHT variable)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "count    101400.000000\n",
       "mean          7.258066\n",
       "std           1.329461\n",
       "min           0.187500\n",
       "25%           6.625000\n",
       "50%           7.375000\n",
       "75%           8.062500\n",
       "max          13.062500\n",
       "Name: BWEIGHT, dtype: float64"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "bweight_data.BWEIGHT.describe()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Histogram plot for the BWEIGHT variable\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "x = bweight_data[\"BWEIGHT\"]\n",
    "mu = 7.258066 #mean\n",
    "sigma = 1.329461 #standard deviation\n",
    "plt.xlabel(\"Weight of a baby(in kgs)\")\n",
    "plt.ylabel(\"Frquency\")\n",
    "n, bins, patches = plt.hist(x,30,density=True)\n",
    "y = scipy.stats.norm.pdf( bins, mu, sigma)\n",
    "l = plt.plot(bins, y, 'r--')\n",
    "plt.show()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Skewness and Kurtosis of the BWEIGHT"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Kurtosis: 2.868579195051929\n",
      "Skewness: -0.9365796191651633\n"
     ]
    }
   ],
   "source": [
    "print(\"Kurtosis: \"+ str(scipy.stats.kurtosis(x)))\n",
    "print(\"Skewness: \"+ str(scipy.stats.skew(x)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As the Skewness is -0.93 which is moderately skewed, this means the most of the babies weigh more than the mean."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Introducing dummy variables"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "dummy = pd.get_dummies(bweight_data,columns=['HISPMOM','HISPDAD'],drop_first=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Variable selection from the pool of 35 variables based on correlation score with the target variable BWEIGHT"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "T = dummy[dummy.columns[:]].corr()['BWEIGHT']\n",
    "i = 0\n",
    "train = pd.DataFrame()\n",
    "for col in dummy:\n",
    "    if(T[i] >= 0.04 or T[i] <=-0.04):\n",
    "        t = dummy[col]\n",
    "        train[col] = t\n",
    "    i += 1\n",
    "train = train.drop(columns = ['BWEIGHT'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Checking for missing data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "ID           0\n",
       "SEX          0\n",
       "MARITAL      0\n",
       "FAGE         0\n",
       "GAINED       0\n",
       "VISITS       0\n",
       "MAGE         0\n",
       "FEDUC        0\n",
       "MEDUC        0\n",
       "TOTALP       0\n",
       "BDEAD        0\n",
       "TERMS        0\n",
       "LOUTCOME     0\n",
       "WEEKS        0\n",
       "RACEMOM      0\n",
       "RACEDAD      0\n",
       "CIGNUM       0\n",
       "DRINKNUM     0\n",
       "ANEMIA       0\n",
       "CARDIAC      0\n",
       "ACLUNG       0\n",
       "DIABETES     0\n",
       "HERPES       0\n",
       "HYDRAM       0\n",
       "HEMOGLOB     0\n",
       "HYPERCH      0\n",
       "HYPERPR      0\n",
       "ECLAMP       0\n",
       "CERVIX       0\n",
       "PINFANT      0\n",
       "PRETERM      0\n",
       "RENAL        0\n",
       "RHSEN        0\n",
       "UTERINE      0\n",
       "BWEIGHT      0\n",
       "HISPMOM_M    0\n",
       "HISPMOM_N    0\n",
       "HISPMOM_O    0\n",
       "HISPMOM_P    0\n",
       "HISPMOM_S    0\n",
       "HISPMOM_U    0\n",
       "HISPDAD_M    0\n",
       "HISPDAD_N    0\n",
       "HISPDAD_O    0\n",
       "HISPDAD_P    0\n",
       "HISPDAD_S    0\n",
       "HISPDAD_U    0\n",
       "dtype: int64"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dummy.isnull().sum()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Randomly splitting the dataset into training, Tr (80%) and testing, Te (20%)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(81120, 20) (81120,)\n",
      "(20280, 20) (20280,)\n"
     ]
    }
   ],
   "source": [
    "y = bweight_data[\"BWEIGHT\"]\n",
    "X_train, X_test, y_train, y_test = train_test_split(train, y, test_size=0.2)\n",
    "print (X_train.shape, y_train.shape)\n",
    "print (X_test.shape, y_test.shape)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### On the training dataset, applying a normalization technique"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(81120, 20)\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "\"\\nfor i, col in enumerate(features):\\n    plt.subplot(1, len(features) , i+1)\\n    x = X_tr_norm[col]\\n    y = target\\n    plt.scatter(x, y, marker='o')\\n    plt.title(col)\\n    plt.xlabel(col)\\n    plt.ylabel('BWEIGHT')\\n\""
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 1440x360 with 0 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "X_tr_norm = (X_train - X_train.min())/(X_train.max()-X_train.min())\n",
    "y_tr_norm = (y_train - y_train.min())/(y_train.max()-y_train.min())\n",
    "print(X_tr_norm.shape)\n",
    "plt.figure(figsize=(20, 5))\n",
    "\n",
    "features = ['VISITS','WEEKS', 'FAGE','GAINED']\n",
    "target = y_tr_norm\n",
    "'''\n",
    "for i, col in enumerate(features):\n",
    "    plt.subplot(1, len(features) , i+1)\n",
    "    x = X_tr_norm[col]\n",
    "    y = target\n",
    "    plt.scatter(x, y, marker='o')\n",
    "    plt.title(col)\n",
    "    plt.xlabel(col)\n",
    "    plt.ylabel('BWEIGHT')\n",
    "'''"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Applying the training data statistics to normalize the testing data as well."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "X_te_norm = (X_test - X_test.min())/(X_test.max()-X_test.min())\n",
    "y_te_norm = (y_test - y_test.min())/(y_test.max()-y_test.min())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### TASK 2: \"Gradient Descent\" function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [],
   "source": [
    "def cal_cost(theta,X,y):\n",
    "    m =len(y)\n",
    "    predict = np.dot(X,theta)\n",
    "    cost = (1/2*m) * np.sum(np.square(predict-y))\n",
    "    return cost\n",
    "\n",
    "def grad_desc(X,y,theta,learn_rate,itera):\n",
    "    m =len(y)\n",
    "    history_cost = np.zeros(itera)\n",
    "    history_theta = np.zeros((itera,X.shape[1]))\n",
    "    for i in range(itera):\n",
    "        predict = np.dot(X,theta)\n",
    "        theta = theta - (1/m)*learn_rate*(np.dot(np.transpose(X),(predict - y)))\n",
    "        history_theta[i,:] = np.transpose(theta)\n",
    "        history_cost[i] = cal_cost(theta,X,y)\n",
    "    return theta, history_cost, history_theta\n",
    "\n",
    "\n",
    "lr=0.01\n",
    "it=10000\n",
    "X_a = np.c_[np.ones((len(X_tr_norm),1)),X_tr_norm]\n",
    "y_a = np.c_[y_tr_norm]\n",
    "theta = np.random.randn(X_a.shape[1],1)\n",
    "theta,cost_history,theta_history = grad_desc(X_a,y_a,theta,lr,it)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Predicting BWEIGHT target variable for each of the testing dataset using the regression line and Calculating  RMSE (Root Mean Squared Error)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.9278963709025224\n"
     ]
    }
   ],
   "source": [
    "X = np.c_[np.ones((len(X_te_norm),1)),X_te_norm]\n",
    "y_predict = np.dot(X,theta)\n",
    "y_test = np.c_[y_te_norm]\n",
    "rmse = np.sqrt(np.mean((y_test - y_predict)**2))\n",
    "print(rmse)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Experiment With different Learning rate and epoch to decrease the RMSE"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Run linear regression one last time on the whole dataset  (i.e, training+testing which is preprocessed by you above)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [],
   "source": [
    "lrt=0.001\n",
    "itt=10000\n",
    "y_t = bweight_data[\"BWEIGHT\"]\n",
    "X_norm = (train - train.min())/(train.max()-train.min())\n",
    "y_norm = (y_t - y_t.min())/(y_t.max()-y_t.min())\n",
    "X_b = np.c_[np.ones((len(X_norm),1)),X_norm]\n",
    "y_b = np.c_[y_norm]\n",
    "theta1 = np.random.randn(X.shape[1],1)\n",
    "theta1,cost_history1,theta_history1 = grad_desc(X_b,y_b,theta1,lrt,itt)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Preprocess the judge-without-label.csv file to predict the baby weights"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [],
   "source": [
    "data = pd.read_csv(\"judge-without-labels.csv\")\n",
    "dum = pd.get_dummies(data,columns=['HISPMOM','HISPDAD'],drop_first=True)\n",
    "test = pd.DataFrame()\n",
    "for col in train:\n",
    "    t1 = dum[col]\n",
    "    test[col] = t1\n",
    "    \n",
    "test_norm = (test - test.min())/(test.max()-test.min())\n",
    "\n",
    "X_t = np.c_[np.ones((len(test_norm),1)),test_norm]\n",
    "y_predic = np.dot(X_t,theta1)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Predict BWEIGHT for each of the samples from the judge-without-label.csv file, and saving the results in judge-run.csv in the format below."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Actual weight = min_weight + y_predic*(max_weight - min_weight)\n",
    "# bweight min = 0.1875, bweight max = 13.0625 from the above \n",
    "a = 0.187500 + y_predic*(13.0625-0.1875) \n",
    "jud_df = pd.DataFrame(data = np.arange(len(a)),columns=[\"ID\"],index=None,)\n",
    "jud_df['BWEIGHT'] = a\n",
    "jud_df.to_csv(\"judge-run.csv\",index=False)"
   ]
  }
 ],
 "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"
  },
  "varInspector": {
   "cols": {
    "lenName": 16,
    "lenType": 16,
    "lenVar": 40
   },
   "kernels_config": {
    "python": {
     "delete_cmd_postfix": "",
     "delete_cmd_prefix": "del ",
     "library": "var_list.py",
     "varRefreshCmd": "print(var_dic_list())"
    },
    "r": {
     "delete_cmd_postfix": ") ",
     "delete_cmd_prefix": "rm(",
     "library": "var_list.r",
     "varRefreshCmd": "cat(var_dic_list()) "
    }
   },
   "types_to_exclude": [
    "module",
    "function",
    "builtin_function_or_method",
    "instance",
    "_Feature"
   ],
   "window_display": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}