{
"cells": [
{
"cell_type": "markdown",
"metadata": {
"toc": "true"
},
"source": [
"# Table of Contents\n",
" "
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"# What does TensorFlow do?"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"- http://learningtensorflow.com/lesson2/"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"TensorFlow is a way of representing computation without actually performing it until asked. In this sense, it is a form of lazy computing, and it allows for some great improvements to the running of code:\n",
"\n",
"- Faster computation of complex variables\n",
"- Distributed computation across multiple systems, including GPUs.\n",
"- Reduced redundency in some computations"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Let’s have a look at this in action. First, a very basic python script:"
]
},
{
"cell_type": "code",
"execution_count": 1,
"metadata": {
"collapsed": false
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"40\n"
]
}
],
"source": [
"x = 35\n",
"y = x + 5\n",
"print(y)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"This script basically just says “create a variable x with value 35, set the value of a new variable y to that plus 5, which is currently 40, and print it out”. The value 40 will print out when you run this program."
]
},
{
"cell_type": "code",
"execution_count": 2,
"metadata": {
"collapsed": false
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"\n"
]
}
],
"source": [
"import tensorflow as tf\n",
"\n",
"x = tf.constant(35, name='x')\n",
"y = tf.Variable(x + 5, name='y')\n",
"\n",
"print(y)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"After running this, you’ll get quite a funny output, something like ``````. This is clearly not the value 40.\n",
"\n",
"The reason why, is that our program actually does something quite different to the previous one. The code here does the following:\n",
"\n",
"- Import the tensorflow module and call it tf\n",
"- Create a constant value called x, and give it the numerical value 35\n",
"- Create a Variable called y, and define it as being the equation x + 5\n",
"- Print out the equation object for y\n",
"\n",
"The subtle difference is that y isn’t given “the current value of x + 5” as in our previous program. Instead, it is effectively an equation that means “when this variable is computed, take the value of x (as it is then) and add 5 to it”. The computation of the value of y is never actually performed in the above program.\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": 3,
"metadata": {
"collapsed": false
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"40\n"
]
}
],
"source": [
"import tensorflow as tf\n",
"\n",
"x = tf.constant(35, name='x')\n",
"y = tf.Variable(x + 5, name='y')\n",
"\n",
"model = tf.initialize_all_variables()\n",
"\n",
"with tf.Session() as session:\n",
" session.run(model)\n",
" print(session.run(y))"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"We have removed the print(y) statement, and instead we have code that creates a session, and actually computes the value of y. This is quite a bit of boilerplate, but it works like this:\n",
"\n",
"1. Import the tensorflow module and call it tf\n",
"2. Create a constant value called x, and give it the numerical value 35\n",
"3. Create a Variable called y, and define it as being the equation x + 5\n",
"4. Initialize the variables with initialize_all_variables (we will go into more detail on this)\n",
"5. Create a session for computing the values\n",
"6. Run the model created in 4\n",
"7. Run just the variable y and print out its current value\n",
"\n",
"The step 4 above is where some magic happens. In this step, a graph is created of the dependencies between the variables. In this case, the variable y depends on the variable x, and that value is transformed by adding 5 to it. Keep in mind that this value isn’t computed until step 7, as up until then, only equations and relations are computed."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"# Exercises"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Exercise 1\n",
"\n",
"- Constants can also be arrays. Predict what this code will do, then run it to confirm:"
]
},
{
"cell_type": "code",
"execution_count": 4,
"metadata": {
"collapsed": false
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"[40 45 50]\n"
]
}
],
"source": [
"import tensorflow as tf\n",
"\n",
"\n",
"x = tf.constant([35, 40, 45], name='x')\n",
"y = tf.Variable(x + 5, name='y')\n",
"\n",
"\n",
"model = tf.initialize_all_variables()\n",
"\n",
"with tf.Session() as session:\n",
" session.run(model)\n",
" print(session.run(y))"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Exercise 2\n",
"- Generate a NumPy array of 10,000 random numbers (called x) and create a Variable storing the equation"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"$$y = 5x^2 - 3x + 15$$\n",
"\n",
"You can generate the NumPy array using the following code:"
]
},
{
"cell_type": "code",
"execution_count": 5,
"metadata": {
"collapsed": false
},
"outputs": [
{
"data": {
"text/plain": [
"array([136, 612, 947, ..., 205, 238, 803])"
]
},
"execution_count": 5,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"import numpy as np\n",
"data = np.random.randint(1000, size=10000)\n",
"data"
]
},
{
"cell_type": "code",
"execution_count": 6,
"metadata": {
"collapsed": false
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"[ 92087 1870899 4481219 ..., 209525 282521 3221651]\n"
]
}
],
"source": [
"import tensorflow as tf\n",
"\n",
"\n",
"x = tf.constant(data, name='x')\n",
"y = tf.Variable(5*(x**2) - (3*x) + 15, name='y')\n",
"\n",
"\n",
"model = tf.initialize_all_variables()\n",
"\n",
"with tf.Session() as session:\n",
" session.run(model)\n",
" print(session.run(y))"
]
},
{
"cell_type": "markdown",
"metadata": {
"collapsed": true
},
"source": [
"## Exercise 3\n",
"- You can also update variables in loops, which we will use later for machine learning. Take a look at this code, and predict what it will do (then run it to check):"
]
},
{
"cell_type": "code",
"execution_count": 4,
"metadata": {
"collapsed": false
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"1\n",
"2\n",
"3\n",
"4\n",
"5\n"
]
}
],
"source": [
"import tensorflow as tf\n",
"\n",
"x = tf.Variable(0, name='x')\n",
"\n",
"model = tf.initialize_all_variables()\n",
"\n",
"with tf.Session() as session:\n",
" for i in range(5):\n",
" session.run(model)\n",
" x = x + 1\n",
" print(session.run(x))"
]
}
],
"metadata": {
"kernelspec": {
"display_name": "Python 2",
"language": "python",
"name": "python2"
},
"language_info": {
"codemirror_mode": {
"name": "ipython",
"version": 2
},
"file_extension": ".py",
"mimetype": "text/x-python",
"name": "python",
"nbconvert_exporter": "python",
"pygments_lexer": "ipython2",
"version": "2.7.11"
},
"toc": {
"toc_cell": true,
"toc_number_sections": true,
"toc_section_display": "none",
"toc_threshold": "8",
"toc_window_display": true
}
},
"nbformat": 4,
"nbformat_minor": 0
}