"> This work comes from[LearningTensorFlow.com](http://learningtensorflow.com/), developed by[dataPipeline](http://datapipeline.co.au/), with whom the copyright remains. \n",
"For more tutorials and extended exercises, please see the website."
"So far we have used **Variables** to manage our data, but there is a more basic structure, the **placeholder**. A **placeholder** is simply a variable that we will assign data to at a later date. It allows us to create our operations and build our computation graph, without needing the data. In **TensorFlow** terminology, we then feed data into the graph through these placeholders.\n",
"\n"
]
},
{
"cell_type":"code",
"execution_count":1,
"metadata":{
"collapsed":false
},
"outputs":[
{
"name":"stdout",
"output_type":"stream",
"text":[
"[ 2. 4. 6.]\n"
]
}
],
"source":[
"import tensorflow as tf\n",
"\n",
"x = tf.placeholder(\"float\", 3)\n",
"y = x * 2\n",
"\n",
"with tf.Session() as session:\n",
" result = session.run(y, feed_dict={x: [1, 2, 3]})\n",
" print(result)"
]
},
{
"cell_type":"markdown",
"metadata":{},
"source":[
"This example works a little differently from our previous ones, let’s break it down.\n",
"\n",
"First, we import **tensorflow** as normal. Then we create a **placeholder** called x, i.e. a place in memory where we will store value later on. The 3 on this line denotes that we will store three values in this placeholder.\n",
"\n",
"Then, we create a Tensor called, which is the operation of multiplying **x** by 2. Note that we haven’t defined any initial values for x yet.\n",
"\n",
"We now have an operation (**y**) defined, and can now run it in a session. We create a session object, and then run just the y variable. Note that this means, that if we defined a much larger graph of operations, we can run just a small segment of the graph. This subgraph evaluation is actually a bit selling point of TensorFlow, and one that isn’t present in many other libraries that do similar things.\n",
"\n",
"Running **y** requires knowledge about the values of **x**. We define these inside the **feed_dict** argument to run. We state here that the values of x are **[1, 2, 3]**. We run y, giving us the result of **[2, 4, 6]**.\n",
"\n",
"Placeholders do not need to be statically sized. Let’s update our program to allow x to take on any length. Change the definition of x to be:"
]
},
{
"cell_type":"code",
"execution_count":2,
"metadata":{
"collapsed":true
},
"outputs":[],
"source":[
"x = tf.placeholder(\"float\", None)"
]
},
{
"cell_type":"markdown",
"metadata":{},
"source":[
"Now, when we define the values of **x** in the **feed_dict** we can have any number of values. The code should still work, and give the same answer, but now it will also work with any number of values in **feed_dict**.\n",
"\n",
"Placeholders can also have multiple dimensions, allowing for storing arrays. In the following example, we create a 3 by 2 matrix, and store some numbers in it. We then use the same operation as before to do element-wise doubling of the numbers.\n",
" result = session.run(y, feed_dict={x: x_data})\n",
" print(result)"
]
},
{
"cell_type":"markdown",
"metadata":{},
"source":[
"The first dimension of the placeholder is **None**, meaning we can have any number of rows. The second dimension is fixed at 3, meaning each row needs to have three columns of data.\n",
"\n",
"We can extend this to take an arbitrary number of **None** dimensions. In this example, we load up the image from our last lesson, then create a placeholder that stores a slice of that image. The slice is a 2D segment of the image, but each “pixel” has three components (red, green, blue). Therefore, we need **None** for the first two dimensions, but need **3** (or **None** would work) for the last dimension. We then use TensorFlow’s **slice** method to take a subsegment out of the image to operate on."
