Ch2 Intro to Tensorflow/007 - tensorflow API exploration.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Here we go through the API doc for tensorflow, and test various senarious out to get a better understanding of the mechanics of tensorflow"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "import tensorflow as tf\n",
    "from pprint import pprint"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Graph"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "c = tf.constant(4.0)\n",
    "assert c.graph is tf.get_default_graph()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n"
     ]
    }
   ],
   "source": [
    "g = tf.Graph()\n",
    "with g.as_default():\n",
    "    # Define operations and tensors in `g`\n",
    "    c = tf.constant(30.0)\n",
    "    assert c.graph is g\n",
    "    \n",
    "    # now if we go g.finalize, no new operation could be added afterward.\n",
    "    g.finalize()\n",
    "    print(g.finalized)\n",
    "    # uncomment this line, and it should give you an error!\n",
    "    # d = tf.constant(10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[2]]\n"
     ]
    }
   ],
   "source": [
    "g = tf.Graph()\n",
    "with g.as_default():\n",
    "    a = tf.constant([[2]])\n",
    "    b = tf.constant([[1]])\n",
    "    \n",
    "    with g.control_dependencies([a, b]):\n",
    "        c = tf.matmul(a, b)\n",
    "\n",
    "    with tf.Session() as sess:\n",
    "        result = sess.run(c)\n",
    "        print(result)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[2]]\n"
     ]
    }
   ],
   "source": [
    "g = tf.Graph()\n",
    "with g.device('/gpu:0'):\n",
    "    a = tf.constant([[2]])\n",
    "    with tf.Session() as sess:\n",
    "        print(sess.run(a))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "another example\n",
    "```python\n",
    "with g.device('/gpu:0'):\n",
    "  # All operations constructed in this context will be placed\n",
    "  # on GPU 0.\n",
    "  with g.device(None):\n",
    "    # All operations constructed in this context will have no\n",
    "    # assigned device.\n",
    "\n",
    "# Defines a function from `Operation` to device string.\n",
    "def matmul_on_gpu(n):\n",
    "  if n.type == \"MatMul\":\n",
    "    return \"/gpu:0\"\n",
    "  else:\n",
    "    return \"/cpu:0\"\n",
    "\n",
    "with g.device(matmul_on_gpu):\n",
    "  # All operations of type \"MatMul\" constructed in this context\n",
    "  # will be placed on GPU 0; all other operations will be placed\n",
    "  # on CPU 0.\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## constants and variables"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Const_13\n"
     ]
    }
   ],
   "source": [
    "x = tf.constant(1)\n",
    "print(x.op.name)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "with tf.Graph().as_default() as g:\n",
    "    y = tf.constant(1, name='y')\n",
    "    assert y.op.name == 'y', y.op.name\n",
    "    \n",
    "    with g.name_scope('some_scope'):\n",
    "        a = tf.constant(2, name='a')\n",
    "        assert a.op.name == 'some_scope/a', a.op.name"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A full example"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "with tf.Graph().as_default() as g:\n",
    "  c = tf.constant(5.0, name=\"c\")\n",
    "  assert c.op.name == \"c\"\n",
    "  c_1 = tf.constant(6.0, name=\"c\")\n",
    "  assert c_1.op.name == \"c_1\"\n",
    "\n",
    "  # Creates a scope called \"nested\"\n",
    "  with g.name_scope(\"nested\") as scope:\n",
    "    nested_c = tf.constant(10.0, name=\"c\")\n",
    "    assert nested_c.op.name == \"nested/c\"\n",
    "\n",
    "    # Creates a nested scope called \"inner\".\n",
    "    with g.name_scope(\"inner\"):\n",
    "      nested_inner_c = tf.constant(20.0, name=\"c\")\n",
    "      assert nested_inner_c.op.name == \"nested/inner/c\"\n",
    "\n",
    "    # Create a nested scope called \"inner_1\".\n",
    "    with g.name_scope(\"inner\"):\n",
    "      nested_inner_1_c = tf.constant(30.0, name=\"c\")\n",
    "      assert nested_inner_1_c.op.name == \"nested/inner_1/c\"\n",
    "\n",
    "      # Treats `scope` as an absolute name scope, and\n",
    "      # switches to the \"nested/\" scope.\n",
    "      with g.name_scope(scope):\n",
    "        nested_d = tf.constant(40.0, name=\"d\")\n",
    "        assert nested_d.op.name == \"nested/d\"\n",
    "\n",
    "        with g.name_scope(\"\"):\n",
    "          e = tf.constant(50.0, name=\"e\")\n",
    "          assert e.op.name == \"e\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[<tf.Tensor 'c:0' shape=() dtype=float32>,\n",
      " <tf.Tensor 'c:0' shape=() dtype=float32>,\n",
      " <tf.Tensor 'c:0' shape=() dtype=float32>]\n",
      "[<tf.Tensor 'c:0' shape=() dtype=float32>,\n",
      " <tf.Tensor 'c:0' shape=() dtype=float32>,\n",
      " <tf.Tensor 'c:0' shape=() dtype=float32>,\n",
      " <tf.Tensor 'd:0' shape=() dtype=int32>]\n"
     ]
    }
   ],
   "source": [
    "with tf.Graph().as_default() as g:\n",
    "    c = tf.constant(5.0, name='c')\n",
    "    d = tf.constant(4, name='d')\n",
    "    g.add_to_collection('samosa', c)\n",
    "    g.add_to_collection('samosa', c)\n",
    "    g.add_to_collection('samosa', c)\n",
    "    \n",
    "    pprint(g.get_collection('samosa'))\n",
    "    \n",
    "    # the list_ref returns the original list, which\n",
    "    # can be mutated inplace to add or remove tensors.\n",
    "    list_ref = g.get_collection_ref('samosa')\n",
    "    list_ref.append(d)\n",
    "    pprint(g.get_collection('samosa'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    ""
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3.0
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.4.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 0
}