q-1.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import pandas as pd\n",
    "from sklearn.preprocessing import LabelEncoder,OneHotEncoder\n",
    "import sklearn as sk\n",
    "from sklearn.model_selection import train_test_split\n",
    "from sklearn.metrics import r2_score,mean_squared_error,mean_absolute_error\n",
    "from pylab import *\n",
    "import matplotlib\n",
    "import matplotlib.pyplot as plt\n",
    "from sklearn.linear_model import Lasso\n",
    "import copy\n",
    "# from sklearn.utils import check_arrays"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "df=pd.read_csv(\"AdmissionDataset/data.csv\")\n",
    "df\n",
    "X =df.drop(['Chance of Admit ','Serial No.'],axis=1)\n",
    "y=df['Chance of Admit ']\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "*Standardizing consists in subtracting the mean and dividing by the standard deviation.*\n",
    "*The convention that you standardize predictions primarily exists so that the units of the regression coefficients are the same.*\n",
    "*when value are largely diffrent one is population and some other attribute is fraction*"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "X = (X - X.mean())/X.std()#normalize the data(z-mu)/(sigma)\n",
    "# y=(y-y.mean())/y.std()\n",
    "#kyuki actual y ke paas pahuchna hai isliye ,jhe y ko normalize karne ka koi reason nahi lag raha"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2)\n",
    "features=['GRE Score','TOEFL Score','University Rating','SOP','LOR ','CGPA','Research']\n",
    "my_data=pd.concat([X_train,y_train],axis=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "X=X_train"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "ones = np.ones([X.shape[0],1])\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "X = np.concatenate((ones,X),axis=1)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "*values converts it from pandas.core.frame.DataFrame to numpy.ndarray*"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "y\n",
    "y=pd.DataFrame(y_train)\n",
    "y=y.values"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "*basically assumed m=0 and c=0 for each independent variable intially*"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "#set hyper parameters\n",
    "alpha = 0.00001"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "def meanSquareError(y_true, y_pred): \n",
    "    y_true, y_pred = np.array(y_true), np.array(y_pred)\n",
    "    return np.mean(np.square((y_true - y_pred)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "*no of times we have to iterate to minimize rms*"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "iters = 1000000\n",
    "lamda=100\n",
    "itr=0\n",
    "\n",
    "cost=[]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "def gradientDescent(X,y,theta,iters,alpha,lamda):\n",
    "    for i in range(iters):\n",
    "        theta1=copy.deepcopy(theta)\n",
    "        theta1[0][0]=0\n",
    "        theta1=np.sign(theta1)\n",
    "#         for i in range(1,8):\n",
    "#             if theta1[]\n",
    "        theta = theta - (alpha/len(X)) * (np.sum(X * (X @ theta.T - y), axis=0)+(0.5*(theta1*lamda)))\n",
    "    return theta"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "# X_train"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "# X"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "# lam=[.00001,.0001,.001,.01,.1,5,10,15,20,25,100000000500]\n",
    "lam=[]\n",
    "lamda=100000\n",
    "error_list=[]\n",
    "preverror=10000000000000\n",
    "ans=lamda\n",
    "flag=0\n",
    "prev=-1\n",
    "while lamda>0.0000001:\n",
    "    lam.append(lamda)\n",
    "    ridgereg = Lasso(alpha=lamda,max_iter=10000)\n",
    "    ridgereg.fit(X_train,y)\n",
    "    lamda=lamda/10\n",
    "    y_pred = ridgereg.predict(X_test)\n",
    "    error_list.append((1-r2_score(y_test, y_pred)))\n",
    "    \n",
    "    if (1-r2_score(y_test, y_pred)) < preverror:\n",
    "        ans=lamda*10\n",
    "#     prev=lamda\n",
    "    preverror=(1-r2_score(y_test, y_pred))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "ans  1.0000000000000002e-07\n"
     ]
    }
   ],
   "source": [
    "print(\"ans \",ans)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[100000, 10000.0, 1000.0, 100.0, 10.0, 1.0, 0.1, 0.01, 0.001, 0.0001, 1e-05, 1.0000000000000002e-06, 1.0000000000000002e-07]\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "Text(0.5, 1.0, 'Lamda vs Error')"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "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": [
    "fig, ax = plt.subplots()\n",
    "print(lam)\n",
    "ax.plot(lam,error_list)\n",
    "ax.set_xlabel(\"Lamda\", fontsize=10)\n",
    "ax.set_ylabel(\"Error\", fontsize=10)\n",
    "ax.set_title('Lamda vs Error')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1.0047401130604747,\n",
       " 1.0047401130604747,\n",
       " 1.0047401130604747,\n",
       " 1.0047401130604747,\n",
       " 1.0047401130604747,\n",
       " 1.0047401130604747,\n",
       " 0.7513004304541403,\n",
       " 0.17512398260842943,\n",
       " 0.15658607327333718,\n",
       " 0.15553043487490537,\n",
       " 0.1554307880064998,\n",
       " 0.15542131369762213,\n",
       " 0.1554204417757874]"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "error_list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "error  0.02163220250816287\n",
      "error  0.021255085945178435\n",
      "error  0.021199236028817126\n",
      "error  0.02119641955615298\n",
      "error  0.003846768781678424\n",
      "error  0.003232510102805594\n",
      "error  0.003203445448041954\n",
      "error  0.003200862594696751\n",
      "error  0.00320060754548356\n",
      "error  0.003200582072923675\n",
      "error  0.0032005795259910873\n",
      "error  0.003200579271301128\n"
     ]
    }
   ],
   "source": [
    "lamda=100000\n",
    "lam=[]\n",
    "# lam=[.00001,.0001,.001,.01,.1,5,10,15,20,25,500,1000,1200,1500,2000,2500,3000,3500]\n",
    "error_list=[]\n",
    "preverror=1000000000\n",
    "ans=lamda\n",
    "flag=0\n",
    "# prev=-1\n",
    "while lamda>0.000001:\n",
    "    theta = np.zeros([1,8])\n",
    "    lam.append(lamda)\n",
    "    g = gradientDescent(X,y,theta,iters,alpha,lamda)\n",
    "    lamda=lamda/10\n",
    "    betaList=g[0]\n",
    "    y_pred1=[]\n",
    "    ones=np.ones([X_test.shape[0],1])\n",
    "    X_tr2 = np.concatenate((ones,X_test),axis=1)\n",
    "    y_pred1=X_tr2@betaList\n",
    "    error_list.append((1-r2_score(y_test, y_pred1)))\n",
    "    \n",
    "    if (1-r2_score(y_test, y_pred1)) < preverror:\n",
    "        ans=lamda*10\n",
    "#     prev=lamda\n",
    "    preverror=(1-r2_score(y_test, y_pred1))\n",
    "    print(\"error \",meanSquareError(y_test, y_pred1))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "ans  1.0000000000000002e-06\n",
      "[1.025390856357716, 1.0075151049024786, 1.004867755722772, 1.0047342517341742, 0.18234118942659405, 0.15322463356424498, 0.15184693606781186, 0.15172450589906306, 0.15171241627799792, 0.15171120884986, 0.15171108812237577, 0.15171107604978373]\n",
      "[100000, 10000.0, 1000.0, 100.0, 10.0, 1.0, 0.1, 0.01, 0.001, 0.0001, 1e-05, 1.0000000000000002e-06]\n"
     ]
    }
   ],
   "source": [
    "print(\"ans \",ans)\n",
    "print(error_list)\n",
    "print(lam)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1.025390856357716, 1.0075151049024786, 1.004867755722772, 1.0047342517341742, 0.18234118942659405, 0.15322463356424498, 0.15184693606781186, 0.15172450589906306, 0.15171241627799792, 0.15171120884986, 0.15171108812237577, 0.15171107604978373]\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "Text(0.5, 1.0, 'Lamda vs Error')"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "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": [
    "fig, ax = plt.subplots()\n",
    "print(error_list)\n",
    "# print(lam)\n",
    "ax.plot(lam,error_list)\n",
    "ax.set_xlabel(\"Lamda\", fontsize=10)\n",
    "ax.set_ylabel(\"Error\", fontsize=10)\n",
    "ax.set_title('Lamda vs Error')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1.025390856357716,\n",
       " 1.0075151049024786,\n",
       " 1.004867755722772,\n",
       " 1.0047342517341742,\n",
       " 0.18234118942659405,\n",
       " 0.15322463356424498,\n",
       " 0.15184693606781186,\n",
       " 0.15172450589906306,\n",
       " 0.15171241627799792,\n",
       " 0.15171120884986,\n",
       " 0.15171108812237577,\n",
       " 0.15171107604978373]"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "error_list"
   ]
  }
 ],
 "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.6.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}