2-Linear_Regression.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Linear and Logistic Regression"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The model for a linear regression in straightforward:\n",
    "    $$ y = w x + b $$\n",
    "Where $w$ and $b$ are the weights and the bias respectively we wish to learn."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In order to solve a given machine learning problem, one must find a way of constructing a function whose minima encode solutions to the real-world problem at hand. These encodings are performed by the <b>loss function</b>. There are several loss functions that can be used for different problems, and each problem has its optimal loss function.\n",
    "Put another way, the loss function is the mechanism by which a project is transmuted into mathematics.\n",
    "\n",
    "The loss function $\\mathcal{L}$ is a function of the datapoint $x$ and labels $y$, then we have $\\mathcal{L(x,y)}$. Note: $x$ and $y$ are in general tensors, and $\\mathcal{L}$ maps the pairs of tensors to scalars. \n",
    "What should the functional form of the loss function be? The common assumption is to make the loss <i>additive</i>. Suppose that $(x_i,y_i)$ are the data available and that there are N total samples. Then the loss can be decomposed as:\n",
    "$$\\mathcal{L(x,y)} = \\sum_{i=1}^{N} \\mathcal{L_i(x_i,y_i)} $$\n",
    "\n",
    "This decomposition allows for many useful advantages. The first is that derivatives factor through addition, so computing the gradient of the total loss simplifies as follows:\n",
    "$$\\nabla\\mathcal{L(x,y)} = \\sum_{i=1}^{N} \\nabla\\mathcal{L_i(x_i,y_i)}$$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "For regression problem we have the <b>$L^2$ loss </b>.\n",
    "$$\\mathcal{L(x,y)} = || f(x) - y ||_2$$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Gradient descent\n",
    "\n",
    "We have explained that machine learning is the act of minimising suitably defined loss functions. That is, we attempt to find arguments to the loss funciton that minimise it. \n",
    "However we recall that $(x,y)$ are fixed quantities that cannot be changed. So, what arguments of $\\mathcal{L}$ are we changing during learning?\n",
    "\n",
    "Defining learnable weights W. Suppose $f(x)$ as a differentiable function we wish to fit with our machine learning model. We will dictate that $f$ is parametrized by choice of W. That is, our function actually has two arguments $f(W,x)$. Fixing the value of W we obtain a function that depends only on datapoints $x$. These learnable weights are the quantities selected by minimisation of the loss function.\n",
    "\n",
    "But now, supposing we have encoded our learning problem with a suitable loss function, how can we find minima of this loss in practice? The key is the <b>gradient descent</b>.\n",
    "Suppose $f$ as a function that depends on some weights W. Then $\\nabla W$ denotes the direction change in W that would maximally increase $f$. It follows that taking a step in the opposite direction would get us closer to the minima of $f$.\n",
    "\n",
    "Note: it's convenient to write \n",
    "$$\\nabla W = \\frac{\\partial \\mathcal{L}}{\\partial W}$$.\n",
    "\n",
    "Then the idea of gradient descent is to find the minima of functionsby repeatedly following the negative gradient. Algorithmically, this update rule can be expressed as:\n",
    "\n",
    "$$W = W - \\alpha\\nabla W$$\n",
    "\n",
    "where $\\alpha$ represents the step-size of the updating process, it is called <i>learning rate</i>. Note that $\\nabla W$ is itself a function of W, so the actual step changes at each iteration. Each step performs an update to the weights matrix W. This iterative process is called <i>learning</i>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Perceptron\n",
    "\n",
    "\n",
    "Proposed in 1958 by Rosenblatt (American psicologist) it is an entity with an input layer $x$, a binary output layer $y$, and a single cell containing the learning algorithm based on the minimization of an error function.\n",
    "It falls into the class of linear discriminant models through the action of a nonlinear transformation on the input vector. Mathematically:\n",
    "\n",
    "$$\\begin{equation}y(x,w) = f\\big{(}\\sum_{j=1}^{M} w_{j}\\phi_{j}(x)\\big{)}\\end{equation}$$\n",
    "\n",
    "Where $x$ is the input vector, $w$ is the adaptive \"weights\" vector associated with $x$, $y$ is the output and $\\phi$ is the fixed (non adaptive) nonlinear funciton of the input. The non linear function. $f(\\bullet)$ is given by a step function of the form:\n",
    "\n",
    "$$\\begin{equation} f(a) = \\begin{cases} +1, \\quad a \\ge 0 \\\\ -1, \\quad a \\lt 0 \\end{cases} \\end{equation}$$\n",
    "\n",
    "For the perceptron it is more convenient to use as target values $t = +1$ for class $C_1$ and $t=-1$ for class $C_2$ which match the choice for the activation function.\n",
    "\n",
    "\n",
    "\n",
    "The algorithm used to determine the adaptive parameters $w$ relies on the minimization of an appropriate error function. A natural choice of error function would be the total number of misclassified patterns. However this does not lead to a simple learning algorithm. We will use the **perceptron criterion**. We are seeking for an error function such that patterns $x_n$ in class $C_1$ will have $w^{T}\\phi(x_n) \\gt 0$ whereas patterns in class $C_2$ have $w^{T}\\phi(x_n) \\lt 0$. Using the $t \\in {-1, +1}$ target coding it naturally follows that we would like that for all patterns $x_n$   :   $w^{T}\\phi(x_n)t_n \\gt 0$. Therefore the perceptron criterion associates zero with each pattern correctly classified whereas for a misclassified pattern $x_n$ it tries to minimize the error function:\n",
    "\n",
    "$$\\begin{equation}E_{P}(w) = - \\sum_{n \\in M} w^{T}\\phi(x_n)t_{n} \\end{equation}$$\n",
    "\n",
    "Where $M$ denotes the set of all misclassified patterns. The error function is a linear function of the weights in the region of misclassification and 0 in the region of a correct classification and therefore it is piecewise linear.\n",
    "This is really important for the next part. \n",
    "\n",
    "Suppose we randomly choose our initial weight vector and then compute the error function associated, how can the machine adapt the weight vector for the best possible classification of patterns $x_n$? . The technique used for the weight update is called **Stochastic gradient descent**. Given $w^{\\tau}$ the weight vector at the $\\tau$ iteration then:\n",
    "\n",
    "$$\\begin{equation} w^{\\tau + 1} = w^{\\tau} -\\eta\\nabla E_P(w) = w^{\\tau} + \\eta \\phi_{n}t_{n} \\end{equation}$$\n",
    "\n",
    "Where $\\eta$ is the learning rate parameter, it sets the precision of our model to find the minimum of the error function but maximize the convengerce time. Large $\\eta$ means big steps, less precision but few iterations. On the other hand a small $\\eta$ means good approximation of the minimum of the error function but more iterations and more computational time. Note that as the iteration goes on the set of misclassified patterns $M$ will change with the vector $w$.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The perceptron is the logic unit we will use to build our models. In order to implement a perceptron or a multi-layer perceptron is important to understand the logic bearing behind. For this purpose is important to understand the computational graphs. These graphs are the representation of the implementation of the algorithm. for example: given 3 input variables, the computational graphs of the function\n",
    "$$f(x) = sign(\\sum_i w_ix_i + b$$\n",
    "is the following:\n",
    "\n",
    "# <img style=\"text-align: left\" src=\"./images/computational_graphs.png\" width=\"40%\" />\n",
    "\n",
    "Where: <ol>\n",
    "    <li> White nodes correspond to input and outputs; </li>\n",
    "    <li> Red nodes correspond to model parameters; </li>\n",
    "    <li> Blue nodes correspond to intermediate operations. </li>\n",
    "    </ol>\n",
    " \n",
    "Clearly, in terms of tensor operation, f can be rewritten as:\n",
    "$$f(x) = sign(\\textbf{w}^T\\textbf{x}) + b$$\n",
    "for which the correspondingcomputational graphs of f is:\n",
    "<img style=\"text-align: left\" src=\"./images/computational_graphs_vec.png\" width=\"40%\" />\n",
    "\n",
    "We have now to implement our algorithm, following these computational graphs."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Toy dataset with numpy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Generating a dataset with numpy.\n",
    "import numpy as np\n",
    "\n",
    "N = 1000\n",
    "\n",
    "w = 5\n",
    "b = 2\n",
    "noise = 0.2\n",
    "\n",
    "x = np.random.rand(N,1) #Random values from uniform distrib in [0,1]\n",
    "ns = np.random.normal(scale = noise, size = (N,1))\n",
    "\n",
    "y = np.reshape(w*x + b + ns, (-1))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<Figure size 1000x800 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "\n",
    "fig = plt.figure(figsize = (10,8))\n",
    "plt.scatter(x,y,color = 'orange')\n",
    "plt.xlabel(\"y\")\n",
    "plt.ylabel(\"x\")\n",
    "plt.title(\"Toy Linear Regression Data, \"\n",
    "        r\"$y = {}x + 2 + Noise(0, {})$\".format(w,b,ns))\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Placeholders"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A placeholder is a way to put information into a tensorflow computation graph. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<tf.Tensor 'Placeholder:0' shape=(2, 2) dtype=float32>"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import tensorflow as tf\n",
    "ph = tf.placeholder(tf.float32, shape = (2,2))\n",
    "ph"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Recall that in TF we can evaluate tensors by using sess.run(var). How do we feed in values for placeholders in our TF computations? \n",
    "We can build <i>feed dictionaries</i>. These are python dictionaries that map TF tensors to np.ndarray objects that contain the concrete values for these placeholders. This is best viewed as an inout to a TF computation graph. And the output?\n",
    "TF calls these output <i>fetches</i>. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[3. 5.]\n"
     ]
    }
   ],
   "source": [
    "a = tf.placeholder(tf.float32, shape = (2,))\n",
    "b = tf.placeholder(tf.float32, shape = (2,))\n",
    "c = a + b\n",
    "\n",
    "x = np.array([1.,2.])\n",
    "y = np.array([2.,3.])\n",
    "with tf.Session() as sess:\n",
    "    dic = {a : x, b: y}\n",
    "    c_eval = sess.run(c, dic) #broadcasting\n",
    "    print(c_eval)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Name scopes"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In complicated TF programs, there will be many tensors, variables and placehoders defined. <code>tf.name_scope(name)</code> provides a simple scoping mechanism for managing these collections of variables. All the computational graph elements created within the scope of <code>tf.name_scope(name)</code> call will have <b>name</b> prepended to their names."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<tf.Tensor 'placeholders/Placeholder:0' shape=(10, 1) dtype=float32>"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "N = 10\n",
    "\n",
    "with tf.name_scope(\"placeholders\"):\n",
    "    x = tf.placeholder(tf.float32, (N,1))\n",
    "    y = tf.placeholder(tf.float32, (N,))\n",
    "\n",
    "x"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Optimizers"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The missing piece is that we still don't know how to perform gradient descent using TF. \n",
    "TF provides a collection of optimization algorithms in the <code>tf.train</code> module. These algorithms can be added as nodes to the TF computation graph."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "W = tf.fill((10,10), value = 1.)\n",
    "\n",
    "with tf.Session() as sess:\n",
    "    red_sum = tf.reduce_sum(W)\n",
    "    red_sum.eval()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "learning_rate = .001\n",
    "W = tf.Variable((10.,))\n",
    "l = tf.reduce_sum(W)\n",
    "with tf.name_scope(\"optim\"):\n",
    "    train_op = tf.train.AdamOptimizer(learning_rate).minimize(l)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Taking gradients with TensorFlow\n",
    "\n",
    "We can directly implement gradient descent algorithms in TF."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Gradient object: [<tf.Tensor 'gradients/Sum_2_grad/Tile:0' shape=(3, 3) dtype=float32>]\n",
      "Type:  <class 'list'>\n",
      "Gradient computed:\n",
      "  [[1. 1. 1.]\n",
      " [1. 1. 1.]\n",
      " [1. 1. 1.]]\n"
     ]
    }
   ],
   "source": [
    "\n",
    "with tf.Session() as sess:\n",
    "    W = tf.fill((3,3),value = 3.)\n",
    "    l = tf.reduce_sum(W)\n",
    "    gradW = tf.gradients(l,W)\n",
    "    print(\"Gradient object:\", (gradW))\n",
    "    print(\"Type: \",(type(gradW)))\n",
    "    print(\"Gradient computed:\\n \",(gradW[0].eval()))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This piece of code symbolically pulls down the gradients of loss <i>l</i> with respect to learnable parameter (<code>tf.Variable</code>)W. \n",
    "<code>tf.gradients</code> returns a list of the desired gradients. Note that the radients are themselves tensors! \n",
    "TF performs symbolic differentiation, which means that gradients themselves are parts of the computational graph."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Gettin a visual understanding of the structure of a tensorial program can be very useful. The TF team provides the TensorBoard package for this purpose. TensorBoard starts a web servers that displays various useful visualizations of a TensorFlow program. However, in order for TF programs to be inspected with TensorBoard, programmers must manually write logging statements. <code>tf.train.FileWriter()</code> speifies the logging directory for a TensorBoard program, and <code>tf.summary</code> writes sumaries of various TensorFlow variables to the specified loggign directory. We will use <code>tf.summary.scalar</code> which sumarizes a scalar quantity, to track the value of the loss function. <code>tf.summary.merge_all()</code> is a useful logging aid that merges myltiple summaries into a single summary for convenience."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "with tf.name_scope(\"summaries\"):\n",
    "    \n",
    "    tf.summary.scalar(\"loss\",l)\n",
    "    merged = tf.summary.merge_all()\n",
    "    \n",
    "train_writer = tf.summary.FileWriter(\"./Output/lr-train\", tf.get_default_graph())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Training models with TF"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Suppose now that we have specified placeholders for datapoints and labels, and have defined a loss with tensorial operations. We have added an optimizer node <code>train_op</code> to the computational graph, which we can use to perform gradient descent steps.\n",
    "To perform iteratively the gradient descent we can use a for-loop. \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Generating a dataset with numpy.\n",
    "import numpy as np\n",
    "import tensorflow as tf\n",
    "\n",
    "N = 1000\n",
    "\n",
    "w = 5\n",
    "b = 2\n",
    "noise = 0.2\n",
    "\n",
    "x_np = np.random.rand(N,1) #Random values from uniform distrib in [0,1]\n",
    "ns = np.random.normal(scale = noise, size = (N,1))\n",
    "\n",
    "y_np = w*x_np + b + ns\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "WARNING: Logging before flag parsing goes to stderr.\n",
      "W1213 19:00:08.543423 140099817998144 deprecation.py:323] From /home/wahid/Programs/anaconda3/lib/python3.7/site-packages/tensorflow_core/python/ops/losses/losses_impl.py:121: where (from tensorflow.python.ops.array_ops) is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "Use tf.where in 2.0, which has the same broadcast rule as np.where\n"
     ]
    }
   ],
   "source": [
    "tf.reset_default_graph()\n",
    "\n",
    "with tf.name_scope(\"placeholders\"):\n",
    "    \n",
    "    x = tf.placeholder(tf.float32, (N,1)) #tensor for the x-variable\n",
    "    y = tf.placeholder(tf.float32, (N,1)) #tensor for the y-variable\n",
    "    \n",
    "with tf.name_scope(\"weights\"):\n",
    "    \n",
    "    W = tf.Variable(tf.random_uniform((1,1), minval=-0.1, maxval=0.1)) #Weights\n",
    "    b =  tf.Variable(tf.random_uniform((1,), minval=-0.1, maxval=0.1)) #bias\n",
    "    \n",
    "with tf.name_scope(\"prediction\"):\n",
    "    \n",
    "    y_pred = tf.matmul(x,W) + b #prediction\n",
    "    \n",
    "with tf.name_scope(\"loss\"):\n",
    "    \n",
    "    #l = tf.reduce_sum((y - y_pred)**2)\n",
    "    l = tf.losses.mean_squared_error(labels=y, predictions=y_pred) / 2. #loss function\n",
    "    \n",
    "with tf.name_scope(\"optim\"):\n",
    "    \n",
    "    train_op = tf.train.AdamOptimizer(.001).minimize(l) #train operation\n",
    "    \n",
    "with tf.name_scope(\"summaries\"):\n",
    "    \n",
    "    tf.summary.scalar(\"loss\",l)\n",
    "    merged = tf.summary.merge_all()\n",
    "    \n",
    "train_writer = tf.summary.FileWriter('./Output/lr-train1', tf.get_default_graph())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "n_steps = 10000\n",
    "\n",
    "loss = []\n",
    "\n",
    "with tf.Session() as sess1:\n",
    "    \n",
    "    sess1.run(tf.global_variables_initializer())\n",
    "    #print(tf.global_variables_initializer())\n",
    "    \n",
    "    for i in range(n_steps):\n",
    "        \n",
    "        feed_dict = {x: x_np, y: y_np}\n",
    "        \n",
    "        _,summary,loss_v = sess1.run([train_op, merged, l], feed_dict = feed_dict)\n",
    "        #print(\"step %d, loss: %f\" % (i,loss))\n",
    "         \n",
    "        loss.append(loss_v)\n",
    "        train_writer.add_summary(summary,i)\n",
    "   \n",
    "    \n",
    "    out = sess1.run([y_pred], feed_dict = {x: x_np})    \n",
    "   \n",
    "    #print(type(out))\n",
    "    \n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "#!tensorboard --logdir=./Output/lr-train1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img style=\"text-align: left\" src=\"./images/logic_reg.png\" width=\"50%\" />"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x720 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "\n",
    "plt.figure(figsize = (10,10))\n",
    "plt.plot(x_np, out[0], color = 'red')\n",
    "plt.scatter(x_np,y_np, color = 'orange')\n",
    "plt.xlabel(\"X\")\n",
    "plt.ylabel(\"Y\")\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[<matplotlib.lines.Line2D at 0x7f6b087cc8d0>]"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x576 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig = plt.figure(figsize = (10,8))\n",
    "plt.title(\"Loss function vs Epochs\")\n",
    "plt.xlabel(\"Epochs\")\n",
    "plt.ylabel(\"Loss function\")\n",
    "plt.axhline(y = 0, color = 'r', linestyle = '--')\n",
    "plt.plot(loss)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "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.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}