TensorFlow_Numpy_ComputationalGraph.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import tensorflow as tf"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "''"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#What are Tensors?\n",
    "\"\"\"\n",
    " Tensors are multilinear maps from vector spaces to the real numbers : \n",
    "         A scalar is a tensor; A vector is a tensor; A matrix is a tensor\n",
    "\"\"\"\n",
    "\"\"\"\"\"\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "''"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#Is TensorFlow any similar to NUMPY?\n",
    "\"\"\"\n",
    "TensorFlow and Numpy are quite similar:\n",
    "    Both are N-d array libraries!\n",
    "    Numpy has Ndarray support, but doesn’t offer methods to create tensor functions and automatically compute \n",
    "    derivatives (+ no GPU support)\n",
    "\n",
    "Resemblance to the sexy NUMPY\n",
    "    np.zeros()~~> tf.zeros()\n",
    "    np.array([[1.0, 2.0], [3.0, 4.0]], dtype=np.float32)  ~~> tf.constant([[1.0, 2.0], [3.0, 4.0]])\n",
    "\n",
    "\"\"\"\n",
    "\"\"\"\"\"\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[ 2.  2.]\n",
      "[ 2.  2.]\n",
      "4.0\n",
      "(2, 2)\n",
      "[[ 0.  0.  0.  0.]]\n",
      "[[ 7.  7.]\n",
      " [ 7.  7.]]\n",
      "[[ 4.  6.]\n",
      " [ 4.  6.]]\n"
     ]
    }
   ],
   "source": [
    "a = np.zeros((2,2)); \n",
    "b = np.ones((2,2))\n",
    "c=np.array([[1,2],[3,4]])\n",
    "print(np.sum(b, axis=0))\n",
    "print(np.sum(b, axis=1))\n",
    "print(np.sum(b))\n",
    "print(a.shape)\n",
    "print(np.reshape(a, (1,4)))\n",
    "print(b*4+3)\n",
    "print(np.dot(b,c))#[0][0]=[1,1]*[1,3]=4;[0][1]=[1,1]*[2,4]=6 [Matrix Multiplication]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[ 2.  2.]\n",
      "[ 2.  2.]\n",
      "4.0\n",
      "(2, 2)\n",
      "[[ 0.  0.  0.  0.]]\n",
      "[[ 7.  7.]\n",
      " [ 7.  7.]]\n",
      "[[ 4.  6.]\n",
      " [ 4.  6.]]\n"
     ]
    }
   ],
   "source": [
    "tf.InteractiveSession()#just convenient syntactic sugar for keeping a default session open in ipython\n",
    "a = tf.zeros((2,2)); \n",
    "b = tf.ones((2,2))\n",
    "c=tf.constant([[1,2],[3,4]],dtype=tf.float32)#By Default the dtype is int32\n",
    "print(tf.reduce_sum(b, reduction_indices=0).eval())\n",
    "print(tf.reduce_sum(b, reduction_indices=1).eval())\n",
    "print(tf.reduce_sum(b).eval())\n",
    "print(a.get_shape())\n",
    "print(tf.reshape(a, (1, 4)).eval())\n",
    "print((b*4+3).eval())\n",
    "print(tf.matmul(b,c).eval())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(array([[  5.,  11.],\n",
       "        [ 11.,  25.]], dtype=float32), array([[  5.,  11.],\n",
       "        [ 11.,  25.]], dtype=float32), array([[  5.,  11.],\n",
       "        [ 11.,  25.]], dtype=float32))"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#Converting Python Objects to TensorFlow\n",
    "def python_to_tensor(python_obj):\n",
    "    tf_tensor = tf.convert_to_tensor(python_obj, dtype=tf.float32)\n",
    "    return  tf.matmul(tf_tensor,tf.matrix_transpose(tf_tensor))#Are you expecting a Symmetric matrix :-)\n",
    "# The following calls are equivalent.\n",
    "value_1 = python_to_tensor(tf.constant([[1.0, 2.0], [3.0, 4.0]]))\n",
    "value_2 = python_to_tensor([[1.0, 2.0], [3.0, 4.0]])\n",
    "value_3 = python_to_tensor(np.array([[1.0, 2.0], [3.0, 4.0]], dtype=np.float32))\n",
    "value_1.eval(),value_2.eval(),value_3.eval()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 0.  0.]\n",
      " [ 0.  0.]]\n",
      "Tensor(\"zeros_1:0\", shape=(2, 2), dtype=float32)\n",
      "[[ 0.  0.]\n",
      " [ 0.  0.]]\n"
     ]
    }
   ],
   "source": [
    "#TensorFlow requires explicit evaluation!\n",
    "a = np.zeros((2,2))\n",
    "ta = tf.zeros((2,2))\n",
    "print(a)\n",
    "print(ta)\n",
    "print(ta.eval())#ensorFlow computations define a computation graph that has no numerical value until evaluated"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "35\n",
      "35\n"
     ]
    }
   ],
   "source": [
    "#A Session object encapsulates the environment in which  Tensor objects are evaluated\n",
    "a=tf.constant(5)\n",
    "b=tf.constant(7)\n",
    "c=a*b\n",
    "with tf.Session() as sess:\n",
    "    print(sess.run(c))\n",
    "    print(c.eval())#Just a syntactic sugar for sess.run(c)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "#All computations add nodes to global default graph : Tensor Flow Computation Graph"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "''"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"\"\"\n",
    "TF Variables:\n",
    "    In-Memory Buffers which Contain Tensors\n",
    "    Frequently used to Hold Model Hyper Parameters\n",
    "\"\"\"\n",
    "\"\"\"\"\"\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 1.  1.]\n",
      " [ 1.  1.]]\n",
      "[[ 1.  1.]\n",
      " [ 1.  1.]]\n"
     ]
    }
   ],
   "source": [
    "w1=tf.ones((2,2))\n",
    "w2=tf.Variable(tf.ones((2,2)),name=\"wts\")\n",
    "with tf.Session() as sess:\n",
    "    print(sess.run(w1))\n",
    "    #print(sess.run(w2))#FailedPreconditionError: Attempting to use uninitialized value wts_1\n",
    "    sess.run(tf.global_variables_initializer())\n",
    "    print(sess.run(w2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      ">>>>>>>>>>><<<<<<<<<<<<<<\n",
      "6\n",
      "1 [2, 2, 2]\n",
      "3 [4, 4, 4]\n",
      "5 [6, 6, 6]\n"
     ]
    }
   ],
   "source": [
    "#Updating Variable State:\n",
    "a=tf.constant(3)\n",
    "b=tf.constant(2)\n",
    "c=tf.multiply(a,b)\n",
    "var1=tf.Variable(0,name=\"i\")\n",
    "incr=tf.add(var1,tf.constant(1),name=\"incr\")#Takes two tensor & sums them element wise to produce another tensor\n",
    "update_var1=tf.assign(var1,incr)#Will assign the value \"incr\" to  var1; Returns a (New ?)Tensor with the updated value\n",
    "with tf.Session() as addSession:\n",
    "    addSession.run(tf.global_variables_initializer())\n",
    "    print(\">>>>>>>>>>><<<<<<<<<<<<<<\")\n",
    "    print(addSession.run(c))\n",
    "    for _ in range(3):\n",
    "        addSession.run(update_var1)\n",
    "        print(addSession.run(var1),addSession.run([var1,incr,update_var1]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 0.  0.  0.]\n",
      " [ 0.  0.  0.]]\n"
     ]
    }
   ],
   "source": [
    "#importing Data from Numpy\n",
    "a=np.zeros((2,3))\n",
    "ta=tf.convert_to_tensor(a)\n",
    "#Inputting data with tf.convert_to_tensor() is  convenient, but doesn’t scale.\n",
    "with tf.Session() as sess:\n",
    "    print(sess.run(ta))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "96.0\n",
      "[96.0, array(12.0, dtype=float32), array(8.0, dtype=float32)]\n",
      "[array([ 96.], dtype=float32), array([ 12.], dtype=float32), array([ 8.], dtype=float32)]\n",
      "[array([ 96.,  70.], dtype=float32), array([ 12.,  10.], dtype=float32), array([ 8.,  7.], dtype=float32)]\n",
      "[array([ 96.,  70.], dtype=float32), array([ 12.,  10.], dtype=float32), array([ 8.,  7.], dtype=float32)]\n"
     ]
    }
   ],
   "source": [
    "#Use tf.placeholder variables(Dummy Nodes: Entry point for Data to Computational Graph)\n",
    "#feed_dict: Python Dictionary to map from tf.placeholder to data (numpy arrays, lists etc.)\n",
    "ip1=tf.placeholder(tf.float32)\n",
    "ip2=tf.placeholder(tf.float32)\n",
    "op=tf.multiply(ip1,ip2)\n",
    "with tf.Session() as sess:\n",
    "    #print(sess.run(op))# You must feed a value for placeholder tensor\n",
    "    print(sess.run(op,feed_dict={ip1:12,ip2:8}))\n",
    "    print(sess.run([op,ip1,ip2],feed_dict={ip1:12,ip2:8}))\n",
    "    print(sess.run([op,ip1,ip2],feed_dict={ip1:[12],ip2:[8]}))\n",
    "    print(sess.run([op,ip1,ip2],feed_dict={ip1:[12,10],ip2:[8,7]}))\n",
    "    print(sess.run([op,ip1,ip2],feed_dict={ip1:np.array([12,10]),ip2:np.array([8,7])}))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "test_init_graph = tf.Graph()\n",
    "with test_init_graph.as_default():\n",
    "    test_scalar_var = tf.Variable(2)\n",
    "    incr_scalar=tf.add(test_scalar_var,1)\n",
    "    update_scalar=tf.assign(test_scalar_var,incr_scalar)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Initialized\n",
      "[3]\n",
      "[4]\n",
      "[5]\n",
      "[6]\n"
     ]
    }
   ],
   "source": [
    "with tf.Session(graph=test_init_graph) as session:\n",
    "    tf.global_variables_initializer().run()\n",
    "    print('Initialized')\n",
    "    for i in range(4):\n",
    "        my_scalar_val=session.run([update_scalar])\n",
    "        print(my_scalar_val)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Initialized\n",
      "Inital Val of Variable  [2]\n",
      "To be Assigned Value is  [3]\n",
      "Updated Val of Variable  [3]\n",
      "Inital Val of Variable  [3]\n",
      "To be Assigned Value is  [4]\n",
      "Updated Val of Variable  [4]\n",
      "Inital Val of Variable  [4]\n",
      "To be Assigned Value is  [5]\n",
      "Updated Val of Variable  [5]\n",
      "Inital Val of Variable  [5]\n",
      "To be Assigned Value is  [6]\n",
      "Updated Val of Variable  [6]\n",
      "Inital Val of Variable  [6]\n",
      "To be Assigned Value is  [7]\n",
      "Updated Val of Variable  [7]\n",
      "Inital Val of Variable  [7]\n",
      "To be Assigned Value is  [8]\n",
      "Updated Val of Variable  [8]\n",
      "Inital Val of Variable  [8]\n",
      "To be Assigned Value is  [9]\n",
      "Updated Val of Variable  [9]\n"
     ]
    }
   ],
   "source": [
    "with tf.Session(graph=test_init_graph) as session:\n",
    "    tf.global_variables_initializer().run()\n",
    "    print('Initialized')\n",
    "    for i in range(7):\n",
    "        test_scalar_val=session.run([test_scalar_var])\n",
    "        print(\"Inital Val of Variable \",test_scalar_val)\n",
    "        incr_scalar_val=session.run([incr_scalar])\n",
    "        print(\"To be Assigned Value is \",incr_scalar_val)\n",
    "        my_scalar_val=session.run([update_scalar])\n",
    "        print(\"Updated Val of Variable \",my_scalar_val)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "test_inits_graph = tf.Graph()\n",
    "with test_inits_graph.as_default():\n",
    "    test_scalar_var = tf.Variable(2)\n",
    "    other_scalar_var = tf.Variable(2)\n",
    "    incr_scalar=tf.add(test_scalar_var,1)\n",
    "    update_scalar=tf.assign(test_scalar_var,incr_scalar)\n",
    "    other_scalar=tf.assign(other_scalar_var,incr_scalar)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Initialized\n",
      "Updated Val of Variable  [3]\n",
      "Persistent Value of Variable  [2]\n",
      "Updated Val of Variable  [4]\n",
      "Persistent Value of Variable  [2]\n",
      "Updated Val of Variable  [5]\n",
      "Persistent Value of Variable  [2]\n"
     ]
    }
   ],
   "source": [
    "with tf.Session(graph=test_inits_graph) as session:\n",
    "    tf.global_variables_initializer().run()\n",
    "    print('Initialized')\n",
    "    for i in range(3):\n",
    "        my_scalar_val=session.run([update_scalar])\n",
    "        print(\"Updated Val of Variable \",my_scalar_val)\n",
    "        other_scalar_val=session.run([other_scalar_var])\n",
    "        print(\"Persistent Value of Variable \",other_scalar_val)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Initialized\n",
      "Updated Val of Variable  [3]\n",
      "Persistent Value of Variable  [2]\n",
      "Updated Val of Variable  [4]\n",
      "Persistent Value of Variable  [2]\n",
      "Updated Val of Variable  [5]\n",
      "Persistent Value of Variable  6\n",
      "Updated Val of Variable  [6]\n",
      "Persistent Value of Variable  [6]\n",
      "Updated Val of Variable  [7]\n",
      "Persistent Value of Variable  [6]\n",
      "Updated Val of Variable  [8]\n",
      "Persistent Value of Variable  9\n",
      "Updated Val of Variable  [9]\n",
      "Persistent Value of Variable  [9]\n",
      "Updated Val of Variable  [10]\n",
      "Persistent Value of Variable  [9]\n"
     ]
    }
   ],
   "source": [
    "with tf.Session(graph=test_inits_graph) as session:\n",
    "    tf.global_variables_initializer().run()\n",
    "    print('Initialized')\n",
    "    for i in range(8):\n",
    "        my_scalar_val=session.run([update_scalar])\n",
    "        print(\"Updated Val of Variable \",my_scalar_val)\n",
    "        if i%3==0 or i%3==1:\n",
    "            other_scalar_val=session.run([other_scalar_var])\n",
    "        else:\n",
    "            other_scalar_val,_=session.run([other_scalar_var,other_scalar])\n",
    "        print(\"Persistent Value of Variable \",other_scalar_val)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "tensorflow",
   "language": "python",
   "name": "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.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}