S1/S1_notebook.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Deep Learning With Tensorflow\n",
    "\n",
    "## Introduction\n",
    "\n",
    "Let's start with importing TensorFlow in our project and making sure that we have installed the right version correctly.\n",
    "If you haven't installed TensorFlow yet, you can easily do so using PyPI: https://www.tensorflow.org/install/."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1.10.0\n"
     ]
    }
   ],
   "source": [
    "import tensorflow as tf\n",
    "print(tf.__version__)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Graphs and Sessions\n",
    "Unless you are using the eager execution mode, operations in TensorFlow are not executed immediately. In TensorFlow, the description of the computations is separated from the execution. A typical TensorFlow program constructs a computational graph first, then creates a session to execute the operations in the graph. Let's create a very simple graph and run it in a session to compute the geometric mean of two numbers. In this example we used placeholders to feed the inputs to the graph. By defining a placeholder we tell the model that we will feed the values later, when we execute the graph. Feeding data this was can lead to input/output bottlenecks in large scale applications. We will later see how to read data in parallel while the graph is being executed."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4.0\n"
     ]
    }
   ],
   "source": [
    "# Define the inputs\n",
    "x = tf.placeholder(tf.float32)\n",
    "y = tf.placeholder(tf.float32)\n",
    "\n",
    "# Define the graph\n",
    "g_mean = tf.sqrt(x * y)\n",
    "\n",
    "# Run the graph\n",
    "with tf.Session() as sess:\n",
    "    res = sess.run(g_mean, feed_dict={x: 2, y:8})\n",
    "    print(res)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Constants and Variables\n",
    "\n",
    "We can declare constants and variables to use in a graph. The main differences between these two are:\n",
    "* Constants have constant values whereas variables can change during execution. A typical example of a variable is a trainable weight in a neural network.\n",
    "* Constants are stored in a graph where variables are not. Using constants increases the size of the graph\n",
    "\n",
    "Let's take a look at an example."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.2\n"
     ]
    }
   ],
   "source": [
    "# This block gets an existing variable with a specific name within a variable scope\n",
    "# or creates a new one if no such variable exists\n",
    "# In this case it's identical to using tf.Variable\n",
    "# Variable scopes help us define and reuse variables within a context\n",
    "with tf.variable_scope(\"linear_model\", reuse=tf.AUTO_REUSE):\n",
    "    w = tf.get_variable(\"weight\", dtype=tf.float32, initializer=tf.constant(0.1))\n",
    "    c = tf.get_variable(\"bias\", dtype=tf.float32, initializer=tf.constant(0.0))\n",
    "\n",
    "# here we define our graph\n",
    "model = x * w + c\n",
    "\n",
    "with tf.Session() as sess:\n",
    "    # we need to initialize all variables otherwise it will throw an error\n",
    "    sess.run(tf.global_variables_initializer())\n",
    "    print(sess.run(model, feed_dict={x: 2.0}))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In the example above, we defined a very simple linear model with a single input, weight, and bias. We initialized the variables with constant values and ran the graph to print the initial output. We will later see how to train these variables to fit a function to data."
   ]
  }
 ],
 "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.6.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}