更新時間：2017.5.4

tensorflow 1.0出來了，API和以前有了一些不一樣，所以這裡把把之前的程式碼遷移到新的上面去。（2017.2.27） 
對於一些性質有了新的認識。補充一些新的東西

這一部分內容的所有完整程式碼以及notebook，都可以在我的Github：LearningTensorFlow/2.constant_and_Variable/ 找到。

一.概覽

還記的上節TensorFlow學習（一）：感受一下 的hello word的例子嗎？是不是出現了一些新的程式設計思路和一個函式類等等。我們學任何一門程式語言的時候，都會講一些量的操作，因為這是基本。這節的主要任務就是熟悉最基本的一些量怎麼來定義。 
先列出來，然後一個一個細講。

類：

1.Tensor 
2.Variable

函式

1.constant() 
2.初始化變數的一些函式 
3.placeholder()

二.類講解

Ⅰ.Tensor(tf.Tensor)

官方文件：tf.Tensor

其中GitHub中的示例都是自己寫的，有興趣的可以看一下，更加詳細的把握這個最基本的資料結構的性質。

Tensor類應該是最基本最核心的資料結構了，他表示的是一個操作的輸出，但是他並不接收操作輸出的值，而是提供了在TensorFlow的Session中計算這些值的方法。 
Tensor類主要有兩個目的：

1.一個Tensor能夠作為一個輸入來傳遞給其他的操作（Operation），由此構造了一個連線不同操作的資料流，使得TensorFLow能夠執行一個表示很大，多步驟計算的圖。 
2.在圖被“投放”進一個Session中後，Tensor的值能夠通過把Tensor傳到Seesion.run（）這個函式裡面去得到結果。相同的，也可以用t.eval（）這個函式，其中的t就是你的tensor啦，這個函式可以算是tf.get_default_session().run(t)的簡便寫法。

下面會有詳細例子。這裡有很多的東西是後面的看不懂怎麼辦？看下面的例子，有講解，不懂的硬記下來先。因為這篇文章同時有其他類和函式的講解，你看完這篇文章就都能夠理解了。

from __future__ import print_function,division
import tensorflow as tf

#build a graph
print("build a graph")
a=tf.constant([[1,2],[3,4]])
b=tf.constant([[1,1],[0,1]])
print("a:",a)
print("b:",b)
print("type of a:",type(a))
c=tf.matmul(a,b)
print("c:",c)
print("\n")
#construct a 'Session' to excute the graph
sess=tf.Session()

# Execute the graph and store the value that `c` represents in `result`.
print("excuted in Session")
result_a=sess.run(a)
result_a2=a.eval(session=sess)
print("result_a:\n",result_a)
print("result_a2:\n",result_a2)

result_b=sess.run(b)
print("result_b:\n",result_b)

result_c=sess.run(c)
print("result_c:\n",result_c)

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15
• 16
• 17
• 18
• 19
• 20
• 21
• 22
• 23
• 24
• 25
• 26
• 27
• 28

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15
• 16
• 17
• 18
• 19
• 20
• 21
• 22
• 23
• 24
• 25
• 26
• 27
• 28

結果 

還是像上一節說的，整個程式分為3個過程，首先是建造計算圖，一開始就用constant（）函式弄了兩個tensor分別是a和b（下面有對於constant函式的介紹），然後我們試圖直接輸出a和b，認為能夠輸出兩個矩陣（至少我們以前的程式設計經驗就是這樣），但是輸出並不是兩個矩陣，而是各自度對應的tensor型別。然後我們通過print("type of a:",type(a)) 這句話來輸出a的型別，果然是tensor型別（tensor類）。然後我們把a和b這兩個tensor傳遞給tf.matmul（）函式，這個函式是用來計算矩陣乘法的函式。返回的依然是tensor用c來接受。到這裡為止，印證了之前說了，tensor裡面並不負責儲存值，想要得到值，得去Session中run。我們可以把這部分看做是建立了一個圖但是沒有執行這個圖。 
然後我們構造了一個Session的物件用來執行圖，sess=tf.Session() 。 
最後就是在session裡面執行之前的東西了，可以把一個tensor傳遞到session.run()裡面去，得到其值。等價的也可以用result_a2=a.eval(session=sess) 來得到。那麼返回的結果是什麼呢？比如result_c是一個什麼東西呢？是numpy.ndarray。要是你熟悉numpy的話。 
剛剛這裡例子主要是形象的表示tensor到底是幹嘛的，比抽象的去看要好。接下來就講一下Tensor類的一些屬性和函式成員。

屬性：

device:表示tensor將被產生的裝置名稱 
dtype：tensor元素型別 
graph：這個tensor被哪個圖所有 
name:這個tensor的名稱 
op：產生這個tensor作為輸出的操作（Operation） 
shape：tensor的形狀（返回的是tf.TensorShape這個表示tensor形狀的類） 
value_index:表示這個tensor在其操作結果中的索引

函式： 
tf.Tensor.consumers()：

作用：返回消耗這個tensor的操作列表

tf.Tensor.eval(feed_dict=None, session=None)：

作用： 
在一個Seesion裡面“評估”tensor的值（其實就是計算），首先執行之前的所有必要的操作來產生這個計算這個tensor需要的輸入，然後通過這些輸入產生這個tensor。在激發tensor.eval()這個函式之前，tensor的圖必須已經投入到session裡面，或者一個預設的session是有效的，或者顯式指定session.

引數： 
feed_dict:一個字典，用來表示tensor被feed的值（聯絡placeholder一起看） 
session:（可選） 用來計算（evaluate）這個tensor的session.要是沒有指定的話，那麼就會使用預設的session。

返回： 
表示“計算”結果值的numpy ndarray

tf.Tensor.get_shape()

作用： 
返回tensor的形狀，型別是TensorShape。這個函式不用把圖“投放”到session裡面執行就能夠得到形狀，一般用來debug和得到一些早期的錯誤資訊等等。

例子：

c = tf.constant([[1.0, 2.0, 3.0], [4.0, 5.0, 6.0]])
print(c.get_shape())
==> TensorShape([Dimension(2), Dimension(3)])

d = tf.constant([[1.0, 0.0], [0.0, 1.0], [1.0, 0.0], [0.0, 1.0]])
print(d.get_shape())
==> TensorShape([Dimension(4), Dimension(2)])

# Raises a ValueError, because `c` and `d` do not have compatible
# inner dimensions.
e = tf.matmul(c, d)

f = tf.matmul(c, d, transpose_a=True, transpose_b=True)
print(f.get_shape())
==> TensorShape([Dimension(3), Dimension(4)])

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15

tf.Tensor.set_shape(shape)

作用：
設定更新這個tensor的形狀，
Updates the shape of this tensor.

This method can be called multiple times, and will merge the given shape with the current shape of this tensor. It can be used to provide additional information about the shape of this tensor that cannot be inferred from the graph alone. For example, this can be used to provide additional information about the shapes of images:

_, image_data = tf.TFRecordReader(...).read(...)
image = tf.image.decode_png(image_data, channels=3)

# The height and width dimensions of `image` are data dependent, and
# cannot be computed without executing the op.
print(image.get_shape())
==> TensorShape([Dimension(None), Dimension(None), Dimension(3)])

# We know that each image in this dataset is 28 x 28 pixels.
image.set_shape([28, 28, 3])
print(image.get_shape())
==> TensorShape([Dimension(28), Dimension(28), Dimension(3)])
Args:

shape: A TensorShape representing the shape of this tensor.
Raises:

ValueError: If shape is not compatible with the current shape of this tensor.
Other Methods

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15
• 16
• 17
• 18
• 19
• 20
• 21
• 22
• 23
• 24
• 25

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15
• 16
• 17
• 18
• 19
• 20
• 21
• 22
• 23
• 24
• 25

對於上面這些函式和屬性，我寫了一個完整的示例，放在GitHub上面，因為太多了，就不貼了。

Ⅱ.Variable（tf.Variable）

通過構造一個Variable類的例項在圖中新增一個變數（variable）， 
Variable（）這個建構函式需要初始值，這個初始值可以是一個任何型別任何形狀的Tensor，初始值的形狀和型別決定了這個變數的形狀和型別。構造之後，這個變數的形狀和型別就固定了，他的值可以通過assign()函式（或者assign類似的函式）來改變。如果你想要在之後改變變數的形狀，你就需要assign()函式同時變數的validate_shape=False 
和任何的Tensor一樣，通過Variable（）創造的變數能夠作為圖中其他操作的輸入使用。你也能夠在圖中新增節點，通過對變數進行算術操作。這裡還是說的太抽象了，舉個簡單的例子來說明一下。

from __future__ import print_function,division
import numpy as np
import tensorflow as tf

#create a Variable
w=tf.Variable(initial_value=[[1,2],[3,4]],dtype=tf.float32)
x=tf.Variable(initial_value=[[1,1],[1,1]],dtype=tf.float32)
y=tf.matmul(w,x)
z=tf.sigmoid(y)
print(z)
init_op=tf.global_variables_initializer()


with tf.Session() as session:
    session.run(init_op)
    z=session.run(z)
    print(z)

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15
• 16
• 17

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15
• 16
• 17

結果： 

屬性：

device:這個變數的device 
dtype:變數的元素型別 
graph:存放變數的圖 
initial_value:這個變數的初始值 
initializer :這個變數的初始化器 
name:這個變臉的名字 
**op：**The Operation of this variable.

函式

__init__(initial_value=None, trainable=True, collections=None, validate_shape=True, caching_device=None, name=None, variable_def=None, dtype=None, expected_shape=None, import_scope=None)

作用： 
建立一個新的變數，初始值為initial_value（這個建構函式會建立兩個操作（Op），一個變數OP和一個assignOp來設定變數為其初始化值）

引數: 
initial_value: 一個Tensor型別或者是能夠轉化為Tensor的Python物件型別。它是這個變數的初始值。這個初始值必須指定形狀資訊，不然後面的引數validate_shape需要設定為false。當然也能夠傳入一個無引數可呼叫並且返回制定初始值的物件，在這種情況下，dtype必須指定。 
trainable: 如果為True（預設也為Ture），這個變數就會被新增到圖的集合GraphKeys.TRAINABLE_VARIABLES.中去 ，這個collection被作為優化器類的預設列表。 
collections:圖的collection 鍵列表，新的變數被新增到這些collection中去。預設是[GraphKeys.GLOBAL_VARIABLES]. 
validate_shape: 如果是False的話，就允許變數能夠被一個形狀未知的值初始化，預設是True，表示必須知道形狀。 
caching_device: 可選，描述裝置的字串，表示哪個裝置用來為讀取快取。預設是變數的device， 
name: 可選，變數的名稱 
variable_def: VariableDef protocol buffer. If not None, recreates the Variable object with its contents. variable_def and the other arguments are mutually exclusive. 
dtype: 如果被設定，初始化的值就會按照這裡的型別來定。 
expected_shape: TensorShape型別.要是設定了，那麼初始的值會是這種形狀 
import_scope: Optional string. Name scope to add to the Variable. Only used when initializing from protocol buffer.

assign(value, use_locking=False)

作用：為變數指定一個新的值 
引數： 
value: Tensor,變數的新值 
use_locking: 如果是True，If True, use locking during the assignment.

assign_add(delta, use_locking=False)

作用：為這個變數加上一個值 
引數: 
delta: Tensor,待加的值 
use_locking: If True, use locking during the operation.

assign_sub(delta, use_locking=False)

作用：為這個變數減去一個值 
引數: 
delta: Tensor,待減的值 
use_locking: If True, use locking during the operation.

count_up_to(limit)

Increments this variable until it reaches limit.

When that Op is run it tries to increment the variable by 1. If incrementing the variable would bring it above limit then the Op raises the exception OutOfRangeError.

If no error is raised, the Op outputs the value of the variable before the increment.

This is essentially a shortcut for count_up_to(self, limit).

Args:

limit: value at which incrementing the variable raises an error. 
Returns:

A Tensor that will hold the variable value before the increment. If no other Op modifies this variable, the values produced will all be distinct.

eval(session=None)

作用： 
在一個session裡面，計算並且返回這個變數的值。這個不算是構造圖的方法，它並不會新增一個操作到圖裡面。這個便捷方法需要一個包含這個變數的圖投放到了一個session裡面。要是沒有sesssion，那麼預設的就會使用預設的session。 
引數： 
session: 估算這個變數的Session

v = tf.Variable([1, 2])
init = tf.global_variables_initializer()

with tf.Session() as sess:
    sess.run(init)
    # Usage passing the session explicitly.
    print(v.eval(sess))
    # Usage with the default session.  The 'with' block
    # above makes 'sess' the default session.
    print(v.eval())

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10

get_shape()

作用：返回變數的形狀

initialized_value()

作用： 
返回已經初始化變數的值.你應該使用這個函式來代替使用變數自己來初始化依賴這個變數的值的其他變數。

# Initialize 'v' with a random tensor.
v = tf.Variable(tf.truncated_normal([10, 40]))
# Use `initialized_value` to guarantee that `v` has been
# initialized before its value is used to initialize `w`.
# The random values are picked only once.
w = tf.Variable(v.initialized_value() * 2.0)

• 1
• 2
• 3
• 4
• 5
• 6

• 1
• 2
• 3
• 4
• 5
• 6

load(value, session=None)

作用：把新的值載入到變數裡面 
引數： 
value: 新的變數值 
session: 用來估算這個變數的Session，要是沒有傳遞，就用預設的 
v = tf.Variable([1, 2]) 
init = tf.global_variables_initializer()

from __future__ import  print_function,division
import numpy as np
import tensorflow as tf

v=tf.Variable(initial_value=[1,2])
init=tf.global_variables_initializer()

with tf.Session() as sess:
    sess.run(init)
    #顯式地傳遞session到函式裡面
    v.load(value=[3,4],session=sess)
    print(v.eval(session=sess))

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12

read_value()

作用：返回這個變數的值，在當前的上下文中讀取。返回的是一個含有這個值的Tensor

scatter_sub(sparse_delta, use_locking=False)

Subtracts IndexedSlices from this variable. 
This is essentially a shortcut for scatter_sub(self, sparse_delta.indices, sparse_delta.values). 
Args: 
sparse_delta: IndexedSlices to be subtracted from this variable. 
use_locking: If True, use locking during the operation. 
Returns: 
A Tensor that will hold the new value of this variable after the scattered subtraction has completed. 
Raises: 
ValueError: if sparse_delta is not an IndexedSlices.

set_shape(shape)

作用：改變變數形狀 
引數： 
shape：新的形狀

三.基本函式講解

Ⅰ.“常量”函式

constant（）函式應該是出鏡率很高的函式之一了，所以這裡放在基本函式講解的第一個。這並不是類，而是一個函式，很多初學者容易誤解。

tf.constant(value,dtype=None,shape=None,name=’Const’,verify_shape=False)

作用：建立一個常量tensor 
引數： 
value: 一個dtype型別（如果指定了）的常量值（列表）。要注意的是，要是value是一個列表的話，那麼列表的長度不能夠超過形狀引數指定的大小（如果指定了）。要是列表長度小於指定的，那麼多餘的由列表的最後一個元素來填充。 
dtype: 返回tensor的型別 
shape: 返回的tensor形狀。 
name: tensor的名字 
verify_shape: Boolean that enables verification of a shape of values.

例子：

# -*- coding: utf-8 -*- 
from __future__ import print_function,division
import tensorflow as tf

#build graph
a=tf.constant(1.,name="a")
print("a:",a)
print("name of a:",a.name)
b=tf.constant(1.,shape=[2,2],name="b")
print("b:",b)
print("type of b:",type(b))

#construct session
sess=tf.Session()

#run in session
result_a=sess.run(a)
print("result_a:",result_a)
print("type of result_a:",type(result_a))

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15
• 16
• 17
• 18
• 19

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15
• 16
• 17
• 18
• 19

結果： 

Ⅱ.變數與初始化的一些函式

tf.global_variables()

作用：返回全域性變數（global variables）。（全域性變數是在分散式環境的機器中共享的變數。）Variable（）建構函式或者get_variable（）自動地把新的變數新增到 graph collection GraphKeys.GLOBAL_VARIABLES 中。這個函式返回這個collection中的內容。

tf.local_variables()

作用：返回區域性變數（local variables）。（區域性變數是不做儲存用的，僅僅是用來臨時記錄某些資訊的變數。 比如用來記錄某些epoch數量等等。） local_variable() 函式會自動的新增新的變數到建構函式或者get_variable（）自動地把新的變數新增到 graph collectionGraphKeys.LOCAL_VARIABLES 中。這個函式返回這個collection中的內容。

tf.variables_initializer(var_list, name=’init’)

作用： 
返回一個初始化一列變數的操作（Op）。要是你把圖“投放進一個”session中後，你就能夠通過run 這個操作來初始化變數列表var_list中的變數 
引數： 
var_list: 帶初始化變數列表 
name: 可選，操作的名稱。

tf.global_variables_initializer() 
補充：這個函式很重要，差不多經常碰得到，是替代以前老的tf.initialize_all_variables() 的新方法。

作用： 
返回一個初始化所有全域性變數的操作（Op）。要是你把圖“投放進一個”session中後，你就能夠通過run 這個操作來初始化所有的全域性變數，本質相當於variable_initializers(global_variables())

tf.local_variables_initializer()

作用： 
返回一個初始化所有區域性變數的操作（Op）。要是你把圖“投放進一個”session中後，你就能夠通過run 這個操作來初始化所有的區域性變數，本質相當於variable_initializers(local_variables())

Ⅲ.placeholder()

tf.placeholder(dtype, shape=None, name=None)

作用： 
placeholder的作用可以理解為佔個位置，我並不知道這裡將會是什麼值，但是知道型別和形狀等等一些資訊，先把這些資訊填進去佔個位置，然後以後用feed的方式來把這些資料“填”進去。返回的就是一個用來用來處理feeding一個值的tensor。 
那麼feed的時候一般就會在你之後session的run（）方法中用到feed_dict這個引數了。這個引數的內容就是你要“喂”給那個placeholder的內容（看下例）。

引數： 
dtype: 將要被fed的元素型別 
shape:（可選） 將要被fed的tensor的形狀，要是不指定的話，你能夠fed進任何形狀的tensor。 
name:（可選）這個操作的名字

例子：

x = tf.placeholder(tf.float32, shape=(1024, 1024))
y = tf.matmul(x, x)

with tf.Session() as sess:
  print(sess.run(y))  # ERROR: will fail because x was not fed.
  rand_array = np.random.rand(1024, 1024)
  print(sess.run(y, feed_dict={x: rand_array}))  # Will succeed.

• 1
• 2
• 3
• 4
• 5
• 6
• 7

• 1
• 2
• 3
• 4
• 5
• 6
• 7

四.幾個例子

https://www.tensorflow.org/versions/r0.11/get_started/basic_usage.html 
上面基本把比較常用和基礎的類和函式都分析了一遍，接下來就是通過文件中提供的基本用法把那些東西串聯起來。

再重申一遍，使用TensorFlow的時候，你需要理解的一些tensorflow問題： 
怎麼用圖表示計算； 
在Session裡面計算圖； 
用tensor表示資料； 
用變數保持狀態； 
用feeds（聯絡placeholder）和fetches來從任意的操作（Operation）中“放入”或者“拿出”資料。 
再回憶一下tensorflow的思想：首先是構造過程來“組裝”一個圖，然後是執行過程用session來執行圖中的操作（ops）。那麼下面就用一個綜合的例子聯絡之前對於各個類的分析來加強一些對於tensorflow基礎的理解。

例子一：常量和圖

# -*- coding: utf-8 -*- 

from __future__ import print_function,division
import tensorflow as tf

#building the graph

'''
建立一個常量操作（op）產生 1x2 矩陣，這個操作（op）作為一個節點新增到預設的圖中，但是這裡這個矩陣並不是一個值，而是一個tensor。
建立另外一個常量操作產生一個1x2 矩陣（解釋如上）
'''
mat1=tf.constant([3.,3.],name="mat1")
mat2=tf.constant([4.,4.],name="mat2")

#matrix sum.
s=tf.add(mat1,mat2)

'''
這個預設的圖（grapg）現在已經有3個節點了：兩個constan（）操作和一個add（）操作。為了真正的得到這個和的值，你需要把這個圖投放到一個session裡面執行。
'''

# Launch the default graph.
sess = tf.Session()

'''
為了得到和的值，我們要執行add 操作（op），因此我們在session裡面呼叫“run（）”函式，把代表add op的輸出結果s傳到函式裡面去。表明我們想從add（）操作得到輸出。
'''
result=sess.run(s)
print("result:",result)

# Close the Session when we're done.
sess.close()

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15
• 16
• 17
• 18
• 19
• 20
• 21
• 22
• 23
• 24
• 25
• 26
• 27
• 28
• 29
• 30
• 31
• 32

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15
• 16
• 17
• 18
• 19
• 20
• 21
• 22
• 23
• 24
• 25
• 26
• 27
• 28
• 29
• 30
• 31
• 32

結果： 
 
分析： 
見註釋，其中出來幾個操作的那些很重要。需要好好理解一下。 
還有一種自動關閉session的寫法：

with tf.Session() as sess:
  result = sess.run([product])
  print(result)

• 1
• 2
• 3

• 1
• 2
• 3

例子二：tensor和變數

參照之前的類和函式講解

# -*- coding: utf-8 -*- 

from __future__ import print_function,division
import tensorflow as tf

#building the graph

#Create a Variable, that will be initialized to the scalar value 0.
state=tf.Variable(0,name="state")
print("the name of this variable:",state.name)

# Create an Op to add 1 to `state`.
one = tf.constant(1)
new_value = tf.add(state, one)
update = tf.assign(state, new_value)

# Variables must be initialized by running an `init` Op after having
# launched the graph.  We first have to add the `init` Op to the graph.
init_op = tf.initialize_all_variables()

# Launch the graph and run the ops.
with tf.Session() as sess:
  # Run the 'init' op
  sess.run(init_op)
  # Print the initial value of 'state'
  print(sess.run(state))
  # Run the op that updates 'state' and print 'state'.
  for _ in range(3):
    sess.run(update)
    print("value of state:",sess.run(state))

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15
• 16
• 17
• 18
• 19
• 20
• 21
• 22
• 23
• 24
• 25
• 26
• 27
• 28
• 29
• 30

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15
• 16
• 17
• 18
• 19
• 20
• 21
• 22
• 23
• 24
• 25
• 26
• 27
• 28
• 29
• 30

結果： 
 
分析： 
assign（）的這個函式可以看前面的assign函式的解釋，但是你現在肯定也知道，在seesion中run（）之前，它不會真的執行assign的操作。 
這裡是一個迴圈操作，然後有在迴圈操作中的賦值過程，要是在神經網路中的話，你會有很多的權值需要儲存然後不斷迴圈更新等等，這裡可以讓你體會一下。

例三：fetches和feeds

這裡很重要，因為很多新手在這裡不理解 
Fetches我不知道怎麼翻譯，所以還是就直接用fetches，表示一種取的動作，我們有時候需要在操作裡面取一些輸出，其實就是在執行圖的過程中在run（）函式裡面傳入一個tensor就行，然後就會輸出tesnor的結果，比如上面的session.run(state)就可以當做一個fetch的動作啦。當然不僅僅限於fetch一個，你也可以fetch多個tensor。

feed我們知道是餵養的意思，這個又怎麼理解呢？feed的動作一般和placeholder（）函式一起用，前面說過，placeholder（）起到佔位的作用（參考前面的placeholder（）函式），怎麼理解呢？假如我有一個（堆）資料，但是我也許只知道他的型別，不知道他的值，我就可以先傳進去一個型別，先把這個位置佔著。等到以後再把資料“喂”給這個變數。 
很抽象，那麼舉個例子

# -*- coding: utf-8 -*- 

from __future__ import print_function,division
import tensorflow as tf

#fetch example
print("#fetch example")
a=tf.constant([1.,2.,3.],name="a")
b=tf.constant([4.,5.,6.],name="b")
c=tf.constant([0.,4.,2.],name="c")
add=a+b
mul=add*c

with tf.Session() as sess:
    result=sess.run([a,b,c,add,mul])
    print("after run:\n",result)

print("\n\n")

#feed example
print("feed example")
input1=tf.placeholder(tf.float32)
input2=tf.placeholder(tf.float32)
output=tf.mul(input1,input2)

with tf.Session() as session:
    result_feed=session.run(output,feed_dict={input1:[2.],input2:[3.]})
    print("result:",result_feed)

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15
• 16
• 17
• 18
• 19
• 20
• 21
• 22
• 23
• 24
• 25
• 26
• 27
• 28

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15
• 16
• 17
• 18
• 19
• 20
• 21
• 22
• 23
• 24
• 25
• 26
• 27
• 28

結果： 
 
分析：