Class2_GLM_Poisson_and_Gradient_Descent.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Poisson Regression with boston data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np \n",
    "import matplotlib.pyplot as plt\n",
    "import seaborn as sns\n",
    "import statsmodels.api as sm"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Data manipulation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array(['CRIM', 'ZN', 'INDUS', 'CHAS', 'NOX', 'RM', 'AGE', 'DIS', 'RAD',\n",
       "       'TAX', 'PTRATIO', 'B', 'LSTAT'], dtype='<U7')"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from sklearn import datasets\n",
    "boston = datasets.load_boston()\n",
    "X_train = boston['data']\n",
    "y_train = boston['target'] #number of car accidents\n",
    "boston.feature_names"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([6.320e-03, 1.800e+01, 2.310e+00, 0.000e+00, 5.380e-01, 6.575e+00,\n",
       "       6.520e+01, 4.090e+00, 1.000e+00, 2.960e+02, 1.530e+01, 3.969e+02,\n",
       "       4.980e+00])"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "X_train[0, ]\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "y = np.round_(y_train, decimals=0, out=None) #make into integers"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(506, 13) (506,)\n"
     ]
    }
   ],
   "source": [
    "print(X_train.shape, y.shape)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* X_train does not contain the column of 1's. In the following, we add the column of 1's into the model matrix."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(506, 14)\n"
     ]
    }
   ],
   "source": [
    "my_ones = np.ones([506,1])\n",
    "X = np.concatenate((my_ones, X_train), axis=1)\n",
    "print(X.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "poisson_model = sm.GLM(y, X, family=sm.families.Poisson()) #Find W based on MLE\n",
    "poisson_results = poisson_model.fit();"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "                 Generalized Linear Model Regression Results                  \n",
      "==============================================================================\n",
      "Dep. Variable:                      y   No. Observations:                  506\n",
      "Model:                            GLM   Df Residuals:                      492\n",
      "Model Family:                 Poisson   Df Model:                           13\n",
      "Link Function:                    log   Scale:                          1.0000\n",
      "Method:                          IRLS   Log-Likelihood:                -1416.0\n",
      "Date:                Wed, 25 Nov 2020   Deviance:                       362.69\n",
      "Time:                        16:56:45   Pearson chi2:                     389.\n",
      "No. Iterations:                     5                                         \n",
      "Covariance Type:            nonrobust                                         \n",
      "==============================================================================\n",
      "                 coef    std err          z      P>|z|      [0.025      0.975]\n",
      "------------------------------------------------------------------------------\n",
      "const          3.7780      0.232     16.268      0.000       3.323       4.233\n",
      "x1            -0.0103      0.002     -4.699      0.000      -0.015      -0.006\n",
      "x2             0.0010      0.001      1.900      0.057   -3.29e-05       0.002\n",
      "x3             0.0022      0.003      0.829      0.407      -0.003       0.008\n",
      "x4             0.0922      0.035      2.664      0.008       0.024       0.160\n",
      "x5            -0.6932      0.182     -3.812      0.000      -1.050      -0.337\n",
      "x6             0.1225      0.018      6.735      0.000       0.087       0.158\n",
      "x7             0.0004      0.001      0.627      0.531      -0.001       0.002\n",
      "x8            -0.0490      0.009     -5.614      0.000      -0.066      -0.032\n",
      "x9             0.0154      0.003      4.827      0.000       0.009       0.022\n",
      "x10           -0.0005      0.000     -3.114      0.002      -0.001      -0.000\n",
      "x11           -0.0359      0.006     -6.281      0.000      -0.047      -0.025\n",
      "x12            0.0005      0.000      3.195      0.001       0.000       0.001\n",
      "x13           -0.0314      0.003    -12.235      0.000      -0.036      -0.026\n",
      "==============================================================================\n"
     ]
    }
   ],
   "source": [
    "print(poisson_results.summary()) # almost same\n",
    "# gradient descent algorithm working very well"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# coef 비교를 통해 converge 잘 되었는지 비교"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "yhat = poisson_results.mu #prediction for each observation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "# yhat = poisson_results.predict(X)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "16.7256638587818"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.mean((y_train-yhat)**2)  #Calculation of MSE"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* Calculate MSE again!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "W = poisson_results.params # Estimated parameters"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(506,)\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "16.7256638587818"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "my_yhat = np.exp(np.dot(X, W) )\n",
    "print(my_yhat.shape)\n",
    "\n",
    "np.mean((y_train-my_yhat)**2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Draw plot"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[<matplotlib.lines.Line2D at 0x26440e5ad08>]"
      ]
     },
     "execution_count": 13,
     "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": [
    "import matplotlib.pyplot as plt\n",
    "plt.plot(yhat,y_train, 'o')\n",
    "plt.plot([0, 60], [0,60], 'r-')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Optimization based on Gradient Dsecent"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\anaconda3\\envs\\env\\lib\\site-packages\\ipykernel_launcher.py:1: RuntimeWarning: invalid value encountered in true_divide\n",
      "  \"\"\"Entry point for launching an IPython kernel.\n"
     ]
    }
   ],
   "source": [
    "XX=(X-X.mean(axis=0))/np.std(X, axis=0)\n",
    "# GD algorithm을 쓰려면 X standardized를 해줘야 함"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "XX[:,0]=1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(506, 1)"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Y=y.reshape([506,1])\n",
    "Y.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "import scipy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "def f(beta, X, Y): # this is -1 (beta)\n",
    "    temp = np.exp(np.dot(X,beta))-Y*np.dot(X, beta)+scipy.special.gammaln(Y+1)\n",
    "    return np.sum(temp)\n",
    "\n",
    "def df(beta, X, Y): \n",
    "    # in actual data analysis, using tensorflow, df is freely obtained from f function, derivative(f)\n",
    "    temp = np.exp(np.dot(X,beta))-Y\n",
    "    temp2 = np.mean(X*temp, axis=0)\n",
    "    return temp2.reshape([14,1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "beta0=np.random.normal(0,1,[14,1]) # 설명 변수 13개와 intercept 1개 -> 14개\n",
    "lr=0.001\n",
    "iter1=5000 # iteration : 5000 -> # of data in each iteration : 506\n",
    "# of total data -> 5000 * 506\n",
    "beta=beta0\n",
    "history=np.ones([iter1,])\n",
    "for i in range(0,iter1):\n",
    "    beta = beta - lr * df(beta, XX, Y)\n",
    "    history[i]=f(beta, XX, Y)\n",
    "    #print(\"************************\",  i, \"**********************\",    beta)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[<matplotlib.lines.Line2D at 0x26442023188>]"
      ]
     },
     "execution_count": 20,
     "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": [
    "import matplotlib.pyplot as plt\n",
    "plt.plot(history[:]) \n",
    "# learning curve - flat : learning is over when 1000\n",
    "# x축 : iteration number\n",
    "# negative라서 값이 작을 수록 좋음"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 3.04868941],\n",
       "       [-0.08842327],\n",
       "       [ 0.02424911],\n",
       "       [ 0.01497295],\n",
       "       [ 0.02345328],\n",
       "       [-0.08017817],\n",
       "       [ 0.08606746],\n",
       "       [ 0.01027125],\n",
       "       [-0.1031129 ],\n",
       "       [ 0.13286395],\n",
       "       [-0.08893659],\n",
       "       [-0.07750647],\n",
       "       [ 0.04368704],\n",
       "       [-0.22409618]])"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "beta # coef"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1416.0175012993686"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "f(beta, XX, Y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "my_yhat = np.exp(np.dot(X, W) )\n",
    "my_yhat2 = np.exp(np.dot(XX, beta) )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([24.69482883, 31.57108125, 29.83295113, 28.29189   , 26.02959171,\n",
       "       22.14341111, 18.13403117, 11.96775387, 18.19758204])"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "my_yhat[1:10]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[24.69238147],\n",
       "       [31.57105001],\n",
       "       [29.83301505],\n",
       "       [28.29224977],\n",
       "       [26.02757543],\n",
       "       [22.13989725],\n",
       "       [18.13077489],\n",
       "       [11.96538175],\n",
       "       [18.19394065]])"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "my_yhat2[1:10]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Mini Batch Learning"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# gradient descent의 문제점 : local minimum (지역 최적화)\n",
    "# local minimum에서 빠져나오기 위해 mini batch learning을 실행 \n",
    "# random chosen five i\n",
    "# gradient log f ... iteratation : 5000\n",
    "# # of data in each iter : 5 -> randomly chosen number\n",
    "# # of total data : 5000*5\n",
    "# 데이터 수만 보면 gradient descent가 더 정확함, local minimum에 빠질 수 있다는 문제에도 ...\n",
    "\n",
    "# New concept : 'epoch' ... 데이터의 바퀴 수\n",
    "# important ! how choose all of data\n",
    "# # of data 506\n",
    "# in Mini batch, iter : 100, # of data used in each iteration : 10\n",
    "# # of toal data : 100*10 = 1000 data -> this can be regarded as 2 iterations in GD\n",
    "# -> 여기서 epoch은 2가 됨\n",
    "\n",
    "# efficiency of mini batch -> total number of data, 훨씬 빠름\n",
    "# meaning of epoch -> how many times each observation is used?\n",
    "# = on average, each data is used two times\n",
    "# 506 * 10 = 5000개 data \n",
    "# mini batch에서는 데이터를 10개씩 씀 (batch size)\n",
    "# full gradient descent에서 정의한 후 iteration 뒤에 몇 개의 data가 쓰였는지\n",
    "# 500개 각각의 데이터가 두 번 씩 쓰였다는 의미 : epoch = 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "15000"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "epoch=1000\n",
    "lr=0.001\n",
    "# # of data : 506\n",
    "batch_size=32 # number of data used in each iteration : should be 2^n\n",
    "# Q : how iteration do you want to have to achieve 1000 epoch?\n",
    "# 32 batch size * iteration = 1000*506 (epoch* data)\n",
    "# iteration = epoch*data/batch size (integer)\n",
    "\n",
    "iter_per_epoch = np.array(506/batch_size).astype(int)\n",
    "iter_num = epoch* iter_per_epoch\n",
    "iter_num"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array(15)"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "iter_per_epoch # 15번 iter * 32 batch = 500 data\n",
    "# 15000/1000"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 108,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 108,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "33%10"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [],
   "source": [
    "history=np.ones([epoch,])\n",
    "beta0=np.random.normal(0,1,[14,1])\n",
    "ii=0\n",
    "beta=beta0\n",
    "# per each iter, history save -> 15000번 마다 저장\n",
    "# per each epoch, history save -> 15번 마다 저장 *32 = 500개 데이터\n",
    "for i in range(0, iter_num):\n",
    "    my_batch = np.random.choice(506, batch_size) # 506개 중에서 32개 난수 뽑음\n",
    "    beta = beta - lr * df(beta, XX[my_batch, :], Y[my_batch, :]) # 행에 삽입\n",
    "    if i%iter_per_epoch == 0:\n",
    "        history[ii]=f(beta, XX, Y) # 실제 알고리즘에서 사용 x - 계산 안해도됨\n",
    "        ii=ii+1\n",
    "        # calculate f -> this takes some type"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# sigma -> 1부터 500개까지 사용하면 gd, 여기서 랜덤하게 x matrix, y matrix를 사용해서 리턴하는 것이 mini batch\n",
    "# -> 모든 행을 다 넣어주지 않고 해당하는 만큼의 log likelihood를 계산해서 돌려줌\n",
    "# my batch : 난수 뽑는 것"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[<matplotlib.lines.Line2D at 0x26442096488>]"
      ]
     },
     "execution_count": 28,
     "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": [
    "import matplotlib.pyplot as plt\n",
    "plt.plot(history[:])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 111,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1417.161109014909"
      ]
     },
     "execution_count": 111,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "history[-1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# beta 잘 학습됨"
   ]
  }
 ],
 "metadata": {
  "anaconda-cloud": {},
  "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": 1
}