01-Neural-Network-Basics.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Manual Neural Network"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "class SimpleClass():\n",
    "    \n",
    "    def __init__(self):\n",
    "        print(\"hello\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "s = \"world\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "hello\n"
     ]
    }
   ],
   "source": [
    "x = SimpleClass()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<__main__.SimpleClass at 0x10c919cc0>"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "class SimpleClass():\n",
    "    \n",
    "    def __init__(self, name):\n",
    "        print(\"hello \"+name)\n",
    "    \n",
    "    def yell(self):\n",
    "        print(\"YELLING\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "hello Jose\n"
     ]
    }
   ],
   "source": [
    "x = SimpleClass(\"Jose\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "YELLING\n"
     ]
    }
   ],
   "source": [
    "x.yell()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "collapsed": true,
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "class ExtendClass(SimpleClass):\n",
    "    \n",
    "    def __init__(self):\n",
    "        \n",
    "        super().__init__(\"Jose\")\n",
    "        print(\"EXTEND!\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "hello Jose\n",
      "EXTEND!\n"
     ]
    }
   ],
   "source": [
    "y = ExtendClass()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "YELLING\n"
     ]
    }
   ],
   "source": [
    "y.yell()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "# Manual Neural Network - Operation"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "source": [
    "Operation Class\n",
    "    Input nodes\n",
    "    Output nodes\n",
    "    Global Default Graph Variable\n",
    "    Compute \n",
    "        Overwritten by extended classes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "class Operation():\n",
    "    \n",
    "    def __init__(self,input_nodes=[]):\n",
    "        \n",
    "        self.input_nodes = input_nodes\n",
    "        self.output_nodes = []\n",
    "        \n",
    "        for node in input_nodes:\n",
    "            node.output_nodes.append(self)\n",
    "            \n",
    "        _default_graph.variables.append(self)\n",
    "            \n",
    "    def compute(self):\n",
    "        pass"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "class add(Operation):\n",
    "    \n",
    "    def __init__(self,x,y):\n",
    "        \n",
    "        super().__init__([x,y])\n",
    "        \n",
    "    def compute(self,x_var,y_var):\n",
    "        \n",
    "        self.inputs = [x_var,y_var]\n",
    "        return x_var + y_var"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "class multiply(Operation):\n",
    "    \n",
    "    def __init__(self,x,y):\n",
    "        \n",
    "        super().__init__([x,y])\n",
    "        \n",
    "    def compute(self,x_var,y_var):\n",
    "        \n",
    "        self.inputs = [x_var,y_var]\n",
    "        return x_var * y_var"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "class matmul(Operation):\n",
    "    \n",
    "    def __init__(self,x,y):\n",
    "        \n",
    "        super().__init__([x,y])\n",
    "        \n",
    "    def compute(self,x_var,y_var):\n",
    "        \n",
    "        self.inputs = [x_var,y_var]\n",
    "        return x_var.dot(y_var) # assume x and y are array"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Manual Neural Network - Placeholders and Variables"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "Placeholder - An \"empty\" node that needs a value to be provided to compute output\n",
    "Variables - Changeable parameter of Graph \n",
    "Graph - Global variable connecting variables and placeholders to operations"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "class Placeholder():\n",
    "    \n",
    "    def __init__(self):\n",
    "        \n",
    "        self.output_nodes = []\n",
    "        _default_graph.placeholders.append(self)\n",
    "        "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "class Variable():\n",
    "    \n",
    "    def __init__(self,initial_value=None):\n",
    "        \n",
    "        self.value = initial_value\n",
    "        self.output_nodes = []\n",
    "        \n",
    "        _default_graph.variables.append(self)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "class Graph():\n",
    "    \n",
    "    def __init__(self):\n",
    "        \n",
    "        self.operation = []\n",
    "        self.placeholders = []\n",
    "        self.variables = []\n",
    "    \n",
    "    def set_as_default(self):\n",
    "        \n",
    "        global _default_graph\n",
    "        _default_graph = self"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "z = Ax + b \n",
    "\n",
    "A = 10 \n",
    " \n",
    "b = 1 \n",
    "\n",
    "z = 10x + 1, x = placeholder"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "g = Graph()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "g.set_as_default()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "A = Variable(10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "b = Variable(1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "x = Placeholder()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "y = multiply(A,x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "z = add(y,b)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Manual Neural Network - Session"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "PostOrder Tree Traverlsal "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "import numpy as np"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def traverse_postorder(operation):\n",
    "    \"\"\" \n",
    "    PostOrder Traversal of Nodes. Basically makes sure computations are done in \n",
    "    the correct order (Ax first , then Ax + b). Feel free to copy and paste this code.\n",
    "    It is not super important for understanding the basic fundamentals of deep learning.\n",
    "    \"\"\"\n",
    "    \n",
    "    nodes_postorder = []\n",
    "    def recurse(node):\n",
    "        if isinstance(node, Operation):\n",
    "            for input_node in node.input_nodes:\n",
    "                recurse(input_node)\n",
    "        nodes_postorder.append(node)\n",
    "\n",
    "    recurse(operation)\n",
    "    return nodes_postorder"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "class Session():\n",
    "    \n",
    "    def run(self,operation, feed_dict={}):\n",
    "        \n",
    "        nodes_postorder = traverse_postorder(operation)\n",
    "        \n",
    "        for node in nodes_postorder:\n",
    "            \n",
    "            if type(node) == Placeholder:\n",
    "                \n",
    "                node.output = feed_dict[node]\n",
    "            \n",
    "            elif type(node) == Variable:\n",
    "                \n",
    "                node.output = node.value\n",
    "                \n",
    "            else:\n",
    "                \n",
    "                # OPERATION\n",
    "                node.inputs = [input_node.output for input_node in node.input_nodes]\n",
    "                \n",
    "                node.output = node.compute(*node.inputs)\n",
    "            \n",
    "            if type(node.output) == list:\n",
    "                \n",
    "                node.output = np.array(node.output)\n",
    "                \n",
    "        return operation.output"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "sees = Session()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "result = sees.run(operation=z, feed_dict={x:10})"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "101"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "result"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "g = Graph()\n",
    "\n",
    "g.set_as_default()\n",
    "\n",
    "A = Variable([[10,20], [30,40]])\n",
    "b = Variable([1,2,])\n",
    "\n",
    "x = Placeholder()\n",
    "\n",
    "y = matmul(A,x)\n",
    "\n",
    "z = add(y,b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "sees = Session()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[101, 202],\n",
       "       [301, 402]])"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sees.run(operation=z, feed_dict={x:10})"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Manual Neural Network - Classification Task"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "%matplotlib inline"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def sigmoid(z):\n",
    "    \n",
    "    return 1 / (1+np.exp(-z))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "sample_z = np.linspace(-10,10,100)\n",
    "sample_a = sigmoid(sample_z)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[<matplotlib.lines.Line2D at 0x115b09940>]"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x1127c8358>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.plot(sample_z, sample_a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "class Sigmoid(Operation):\n",
    "    \n",
    "    def __init__(self,z):\n",
    "        \n",
    "        super().__init__([z])\n",
    "        \n",
    "    def compute(self,z_val):\n",
    "        \n",
    "        return 1 / (1 +np.exp(-z_val))\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "from sklearn.datasets import make_blobs"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(array([[  7.3402781 ,   9.36149154],\n",
       "        [  9.13332743,   8.74906102],\n",
       "        [  1.99243535,  -8.85885722],\n",
       "        [  7.38443759,   7.72520389],\n",
       "        [  7.97613887,   8.80878209],\n",
       "        [  7.76974352,   9.50899462],\n",
       "        [  8.3186688 ,  10.1026025 ],\n",
       "        [  8.79588546,   7.28046702],\n",
       "        [  9.81270381,   9.46968531],\n",
       "        [  1.57961049,  -8.17089971],\n",
       "        [  0.06441546,  -9.04982817],\n",
       "        [  7.2075117 ,   7.04533624],\n",
       "        [  9.10704928,   9.0272212 ],\n",
       "        [  1.82921897,  -9.86956281],\n",
       "        [  7.85036314,   7.986659  ],\n",
       "        [  3.04605603,  -7.50486114],\n",
       "        [  1.85582689,  -6.74473432],\n",
       "        [  2.88603902,  -8.85261704],\n",
       "        [ -1.20046211,  -9.55928542],\n",
       "        [  2.00890845,  -9.78471782],\n",
       "        [  7.68945113,   9.01706723],\n",
       "        [  6.42356167,   8.33356412],\n",
       "        [  8.15467319,   7.87489634],\n",
       "        [  1.92000795,  -7.50953708],\n",
       "        [  1.90073973,  -7.24386675],\n",
       "        [  7.7605855 ,   7.05124418],\n",
       "        [  6.90561582,   9.23493842],\n",
       "        [  0.65582768,  -9.5920878 ],\n",
       "        [  1.41804346,  -8.10517372],\n",
       "        [  9.65371965,   9.35409538],\n",
       "        [  1.23053506,  -7.98873571],\n",
       "        [  1.96322881,  -9.50169117],\n",
       "        [  6.11644251,   9.26709393],\n",
       "        [  7.70630321,  10.78862346],\n",
       "        [  0.79580385,  -9.00301023],\n",
       "        [  3.13114921,  -8.6849493 ],\n",
       "        [  1.3970852 ,  -7.25918415],\n",
       "        [  7.27808709,   7.15201886],\n",
       "        [  1.06965742,  -8.1648251 ],\n",
       "        [  6.37298915,   9.77705761],\n",
       "        [  7.24898455,   8.85834104],\n",
       "        [  2.09335725,  -7.66278316],\n",
       "        [  1.05865542,  -8.43841416],\n",
       "        [  6.43807502,   7.85483418],\n",
       "        [  6.94948313,   8.75248232],\n",
       "        [ -0.07326715, -11.69999644],\n",
       "        [  0.61463602,  -9.51908883],\n",
       "        [  1.31977821,  -7.2710667 ],\n",
       "        [  2.72532584,  -7.51956557],\n",
       "        [  8.20949206,  11.90419283]]),\n",
       " array([1, 1, 0, 1, 1, 1, 1, 1, 1, 0, 0, 1, 1, 0, 1, 0, 0, 0, 0, 0, 1, 1, 1,\n",
       "        0, 0, 1, 1, 0, 0, 1, 0, 0, 1, 1, 0, 0, 0, 1, 0, 1, 1, 0, 0, 1, 1, 0,\n",
       "        0, 0, 0, 1]))"
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data = make_blobs(n_samples=50, n_features=2, centers=2, random_state=75)\n",
    "data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tuple"
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(data)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1, 1, 0, 1, 1, 1, 1, 1, 1, 0, 0, 1, 1, 0, 1, 0, 0, 0, 0, 0, 1, 1, 1,\n",
       "       0, 0, 1, 1, 0, 0, 1, 0, 0, 1, 1, 0, 0, 0, 1, 0, 1, 1, 0, 0, 1, 1, 0,\n",
       "       0, 0, 0, 1])"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data[1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "features = data[0]\n",
    "labels = data[1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[  7.3402781 ,   9.36149154],\n",
       "       [  9.13332743,   8.74906102],\n",
       "       [  1.99243535,  -8.85885722],\n",
       "       [  7.38443759,   7.72520389],\n",
       "       [  7.97613887,   8.80878209],\n",
       "       [  7.76974352,   9.50899462],\n",
       "       [  8.3186688 ,  10.1026025 ],\n",
       "       [  8.79588546,   7.28046702],\n",
       "       [  9.81270381,   9.46968531],\n",
       "       [  1.57961049,  -8.17089971],\n",
       "       [  0.06441546,  -9.04982817],\n",
       "       [  7.2075117 ,   7.04533624],\n",
       "       [  9.10704928,   9.0272212 ],\n",
       "       [  1.82921897,  -9.86956281],\n",
       "       [  7.85036314,   7.986659  ],\n",
       "       [  3.04605603,  -7.50486114],\n",
       "       [  1.85582689,  -6.74473432],\n",
       "       [  2.88603902,  -8.85261704],\n",
       "       [ -1.20046211,  -9.55928542],\n",
       "       [  2.00890845,  -9.78471782],\n",
       "       [  7.68945113,   9.01706723],\n",
       "       [  6.42356167,   8.33356412],\n",
       "       [  8.15467319,   7.87489634],\n",
       "       [  1.92000795,  -7.50953708],\n",
       "       [  1.90073973,  -7.24386675],\n",
       "       [  7.7605855 ,   7.05124418],\n",
       "       [  6.90561582,   9.23493842],\n",
       "       [  0.65582768,  -9.5920878 ],\n",
       "       [  1.41804346,  -8.10517372],\n",
       "       [  9.65371965,   9.35409538],\n",
       "       [  1.23053506,  -7.98873571],\n",
       "       [  1.96322881,  -9.50169117],\n",
       "       [  6.11644251,   9.26709393],\n",
       "       [  7.70630321,  10.78862346],\n",
       "       [  0.79580385,  -9.00301023],\n",
       "       [  3.13114921,  -8.6849493 ],\n",
       "       [  1.3970852 ,  -7.25918415],\n",
       "       [  7.27808709,   7.15201886],\n",
       "       [  1.06965742,  -8.1648251 ],\n",
       "       [  6.37298915,   9.77705761],\n",
       "       [  7.24898455,   8.85834104],\n",
       "       [  2.09335725,  -7.66278316],\n",
       "       [  1.05865542,  -8.43841416],\n",
       "       [  6.43807502,   7.85483418],\n",
       "       [  6.94948313,   8.75248232],\n",
       "       [ -0.07326715, -11.69999644],\n",
       "       [  0.61463602,  -9.51908883],\n",
       "       [  1.31977821,  -7.2710667 ],\n",
       "       [  2.72532584,  -7.51956557],\n",
       "       [  8.20949206,  11.90419283]])"
      ]
     },
     "execution_count": 45,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "features"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 7.3402781 ,  9.13332743,  1.99243535,  7.38443759,  7.97613887,\n",
       "        7.76974352,  8.3186688 ,  8.79588546,  9.81270381,  1.57961049,\n",
       "        0.06441546,  7.2075117 ,  9.10704928,  1.82921897,  7.85036314,\n",
       "        3.04605603,  1.85582689,  2.88603902, -1.20046211,  2.00890845,\n",
       "        7.68945113,  6.42356167,  8.15467319,  1.92000795,  1.90073973,\n",
       "        7.7605855 ,  6.90561582,  0.65582768,  1.41804346,  9.65371965,\n",
       "        1.23053506,  1.96322881,  6.11644251,  7.70630321,  0.79580385,\n",
       "        3.13114921,  1.3970852 ,  7.27808709,  1.06965742,  6.37298915,\n",
       "        7.24898455,  2.09335725,  1.05865542,  6.43807502,  6.94948313,\n",
       "       -0.07326715,  0.61463602,  1.31977821,  2.72532584,  8.20949206])"
      ]
     },
     "execution_count": 46,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "features[:,0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.collections.PathCollection at 0x117d38320>"
      ]
     },
     "execution_count": 47,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x117cdc208>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.scatter(features[:,0],features[:,1], c=labels, cmap='coolwarm')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[<matplotlib.lines.Line2D at 0x117d189e8>]"
      ]
     },
     "execution_count": 48,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x117d18860>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "x = np.linspace(0,11,10)\n",
    "y = - x +5\n",
    "plt.scatter(features[:,0],features[:,1], c=labels, cmap='coolwarm')\n",
    "plt.plot(x,y)"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "y = mx + b \n",
    "y = -1x + 5\n",
    "\n",
    "remember that both y and x are features!\n",
    "\n",
    "Feat2 = -1*Feat1 + 5\n",
    "Feat2 + Feat1 - 5 = 0\n",
    "FeatMatrix[1,1] - 5 = 0\n",
    "\n",
    "(1,1) * f - 5 = 0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([13])"
      ]
     },
     "execution_count": 49,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.array([1,1]).dot(np.array([[8],[10]])) - 5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 8],\n",
       "       [10]])"
      ]
     },
     "execution_count": 50,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.array([[8],[10]])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([-13])"
      ]
     },
     "execution_count": 51,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.array([1,1]).dot(np.array([[2],[-10]])) - 5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "g = Graph()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "g.set_as_default()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "x = Placeholder()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "w = Variable([1,1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "b = Variable(-5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "z = add(matmul(w,x),b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "a = Sigmoid(z)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "sess = Session()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.99999773967570205"
      ]
     },
     "execution_count": 60,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sees.run(operation=a, feed_dict={x:[8,10]})"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2.2603242979035746e-06"
      ]
     },
     "execution_count": 62,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sees.run(operation=a, feed_dict={x:[2,-10]})"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "lab_tensorflow",
   "language": "python",
   "name": "lab_tensorflow"
  },
  "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.5.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}