Shoot on the moon and if you miss you will still be among the stars.

Caicloud Github :tensorflow-tutorial
<https://github.com/caicloud/tensorflow-tutorial>
https://github.com/caicloud/tensorflow-tutorial
<https://github.com/caicloud/tensorflow-tutorial>

CSDN: <http://blog.csdn.net/JUNJUN_ZHAO/article/details/79594791>
http://blog.csdn.net/JUNJUN_ZHAO/article/details/79594791
<http://blog.csdn.net/JUNJUN_ZHAO/article/details/79594791>

3.1 计算图的使用
import tensorflow as tf tf.__version__ '1.5.0' ''' 3.12 计算图的使用 ''' import
tensorflowas tf a = tf.constant([1.0, 2.0], name='a') b = tf.constant([2.0, 3.0
], name='b') result = a + b print(result) Tensor("add:0", shape=(2,),
dtype=float32) print(a.graph is tf.get_default_graph()) True
* 定义两个不同的图

import tensorflow as tf g1 = tf.Graph() with g1.as_default(): # 在计算图 g1

initializer=tf.zeros_initializer) g2 = tf.Graph()with g2.as_default(): # 在计算图
g2 中定义变量“v”设置初始值为 1 v = tf.get_variable('v', shape=[1],
initializer=tf.ones_initializer)# 在计算图 g1 中，读取变量‘v’的值 with tf.Session(graph=g1)
as sess: tf.global_variables_initializer().run() with tf.variable_scope('',
reuse=True): # 在计算图 g1 中，变量 ‘v’的值取值应该为 0，所以下面这行会输出[0.]
print(sess.run(tf.get_variable('v'))) # 在计算图 g2 中，读取变量‘v’的值 with
tf.Session(graph=g2)as sess: tf.global_variables_initializer().run() with
tf.variable_scope('',reuse=True): # 在计算图 g2 中，变量 ‘v’的值取值应该为 1，所以下面这行会输出[1.]
print(sess.run(tf.get_variable('v'))) [0.] [1.] import tensorflow as tf a =
tf.constant([1.0, 2.0], name='a') b = tf.constant([2.0, 3.0], name='b') g =
tf.Graph()with g.device('/gpu:0'): result = a + b print(result)
3.2 Tensorflow 数据模型—— 张量

import tensorflow as tf a = tf.constant([1.0, 2.0], name='a') b = tf.constant([
2.0, 3.4], name='b') c = tf.constant([4, 5], name='c') d = tf.constant([4, 5],
name='d', dtype=tf.float32) result = a + b # 类型不匹配 会报错 # result1 = a + c # 指定类型
dtype=tf.float32 正常运行 result2 = a + d print (result) print (result2) sess =
tf.InteractiveSession() print(result.eval()) print(result2.eval()) sess.close()
dtype=float32) [3. 5.4] [5. 7.]

3.3 Tensorflow 运行模型——会话

3.3.1 创建和关闭会话
# 创建一个会话。 sess = tf.Session() # 使用会话得到之前计算的结果。 print(sess.run(result)) #

3.3.2 使用 with statement 来创建会话
# 创建一个 Session ,并通过 Python 的上下文管理器 with 来管理 Session with tf.Session() as sess:
print(sess.run(result))# 不需要调用 sess.close() 函数，当上下文退出时，会话关闭和资源释放将会自用完成。 [3. 5.4]
3.3.3 指定默认会话

* Tensorflow 会自动生成一个默认的计算图 （Graph），如果没有特殊指定，运算会加到这个默认的计算图中。
* Session 有类似的机制，但是 Tensorflow 不会自动生成默认的 Session ，需要 手动指定。
* tf.Tensor.eval() 可以用来计算一个张量的取值。 print(result) sess = tf.Session()3.3 指定默认会话
shape=(2,), dtype=float32) Tensor("add_2:0", shape=(2,), dtype=float32) [3. 5.4]
sess = tf.Session()# 下面的两个命令有相同的功能。 print(sess.run(result))
print(result.eval(session=sess)) sess.close() [3. 5.4] [3. 5.4]
3.3.4 使用 tf.InteractiveSession 构建会话

sess = tf.InteractiveSession() print(result.eval) print(result.eval())
sess.close() <bound method Tensor.eval of <tf.Tensor 'add_2:0' shape=(2,)
dtype=float32>> [3. 5.4]
3.3.5 通过 ConfigProto 配置会话 Session

config = tf.ConfigProto(allow_soft_placement=True, log_device_placement=True)
sess1 = tf.InteractiveSession(config=config) sess2 = tf.Session(config=config)
sess1.close() sess2.close()
* 通过 ConfigProto 可以配置并行的线程数，GPU 分配策略，运算超时时间等参数。
* allow_soft_placement=True 时（默认为False），以下三个条件成立时，GPU 运算可以放到 CPU 上运行。

* 运算无法在 GPU 执行
* 没有指定的 GPU 资源，1. 没有 GPU 2.指定第二个，实际上只有 1个
* 运算输入包含对 CPU 计算结果的引用
* log_device_placement=True 时（默认为 False 减少日志量），为
True时，日志中会记录每个节点被安排在哪个设备上以方便调试。
3.4 Tensorflow 实现神经网络

3.4.1 Tensorflow 游乐场及神经原理简介

Tinker With a Neural Network in Your Browser.
<http://playground.tensorflow.org>:http://playground.tensorflow.org
<http://playground.tensorflow.org>

* 提取问题中实体的特征向量作为神经网络的输入。
* 定义神经网络的结构，并定义如何从神经网络的输入得到输出，也就是前向传播算法。
* 通过训练数据来调整神经网络中参数的取值，也就是训练神经网络的过程。
* 使用训练好的神经网络来预测未知的数据。
3.4.2 前向传播算法（Forward propogation）

3.4.3 三层简单神经网络

import tensorflow as tf # 1. 定义 w1, w2 两个变量，seed=1 设定随机种子 # tf.random_normal

tf.Variable(tf.random_normal([2,3], stddev=1, seed=1)) w2 =
tf.Variable(tf.random_normal([3,1], stddev=1, seed=1)) # 2. 将输入的特征向量定义为一个常量，x

= tf.matmul(a, w2)# 分别初始化 w1,w2 两个变量 # 4.调用会话输出结果 with tf.Session() as sess:
sess.run((w1.initializer, w2.initializer)) print(sess.run(y))# sess =
tf.Session() # sess.run(w1.initializer) # sess.run(w2.initializer) #
print(sess.run(y)) # sess.close()
E:\ProgramData\Anaconda3\lib\site-packages\h5py\__init__.py:36: FutureWarning:
Conversion of the second argument of issubdtype from `float` to `np.floating`
is deprecated. In future, it will be treated as `np.float64 ==
np.dtype(float).type`. from ._conv import register_converters as
_register_converters [[3.957578]]

InternalError: Blas GEMM launch failed : a.shape=(1, 2), b.shape=(2, 3), m=1,
n=3, k=2 [[Node: MatMul = MatMul[T=DT_FLOAT, transpose_a=false,
transpose_b=false,

GPU.

* tf.random_normal 随机生成 2*3 大小的矩阵，服从正太分布 均值 mean,标准差 stddev
* 上面给 w1,w2 赋值时，使用的是 initializer ,当变量多的时候这样就会很麻烦，所以 以后可以使用
tf.global_variables_initializer() 函数来完成初始化所有变量的过程。 w1 =
tf.Variable(tf.random_normal([2,3], stddev=1, seed=1)) w2 =
tf.Variable(tf.random_normal([3,1], stddev=1, seed=1)) top =
tf.global_variables_initializer()with tf.Session() as sess: sess.run(top) print(
'w1:\n',w1.eval(),'\nw2:\n',w2.eval()) w1: [[-0.8113182 1.4845988 0.06532937]
[-2.4427042 0.0992484 0.5912243 ]] w2: [[-0.8113182 ] [ 1.4845988 ] [
0.06532937]]
3.4.4 通过 Tensorflow 训练神经网络模型

feed_dict={x:[[0.7,0.9]]} feed_dict 喂给的输入数据,字典类型，再去指定 x 键，对应的值
# 定义 placeholder 作为存放输入数据的地方，必须指定类型， # 维度不一定要指定，但是，如果确定维度，可以避免出 bug x =
tf.placeholder(tf.float32, shape=(1,2), name='input') a = tf.matmul(x, w1) y =
tf.matmul(a, w2)with tf.Session() as sess:
sess.run(tf.global_variables_initializer())# feed_dict 喂给的 输入数据
print(sess.run(y, feed_dict={x:[[0.7,0.9]]})) [[3.957578]] ''' 增加多个输入 ''' x =
tf.placeholder(tf.float32, shape=(3,2), name='input') a = tf.matmul(x, w1) y =
tf.matmul(a, w2)with tf.Session() as sess:
sess.run(tf.global_variables_initializer()) print(sess.run(y, feed_dict={x:[[0.7
,0.9],[0.1,0.4],[0.5,0.8]]})) [[3.957578 ] [1.1537654] [3.1674924]]
3.4.5 完整神经网络样例程序

import tensorflow as tf # numpy 是一个科学计算的工具包，这里通过 numpy 工具包生成模拟数据集 from
numpy.randomimport RandomState # 定义训练数据 batch 的大小 batch_size = 8 # 定义神经网络的参数 w1
= tf.Variable(tf.random_normal([2, 3], stddev=1, seed=1)) w2 =
tf.Variable(tf.random_normal([3, 1], stddev=1, seed=1)) # 在 shape 的维度上使用 None

tf.placeholder(tf.float32, shape=(None, 2), name='x-input') y_ =
tf.placeholder(tf.float32, shape=(None, 1), name='y-input') # 定义神经网络的前向传播过程 a =
tf.matmul(x, w1) y = tf.matmul(a, w2) y = tf.sigmoid(y)# 定义损失函数和反向传播算法
cross_entropy = -tf.reduce_mean(y_ * tf.log(tf.clip_by_value(y,1e-10, 1.0)) + (1
- y_) * tf.log(tf.clip_by_value(1-y, 1e-10, 1.0))) train_step =
RandomState(1) data_size = 128 X = rdm.rand(data_size, 2) # 定义规则来给出样本的标签，x1 +
x2 < 1 .为正样本 （1），其他为 负样本（0） Y = [[int(x1+x2 < 1)] for (x1, x2) in X ] # 创建
Session 来运行 tf 程序 with tf.Session() as sess: # 初始化变量
sess.run(tf.global_variables_initializer())# 输出目前（未经训练）的参数取值。
print(sess.run(w1)) print(sess.run(w2)) print("\n") # 设定训练的 轮数 STEPS = 5000 for
iin range(STEPS): # 每次选取 batch_size 个样本进行训练 start = (i*batch_size) % data_size
end = (i*batch_size) % data_size + batch_size# 通过选取的样本 训练神经网络，并更新参数
sess.run([train_step, y, y_], feed_dict={x:X[start:end], y_:Y[start:end]})#

feed_dict={x:X, y_:Y}) print("After %d training step(s), cross entropy on all
data is %g" % (i, total_cross_entropy)) ''' 训练完后，神经网络参数的值，w1 ,w2

print(sess.run(w1)) print(sess.run(w2)) [[-0.8113182 1.4845988 0.06532937]
[-2.4427042 0.0992484 0.5912243 ]] [[-0.8113182 ] [ 1.4845988 ] [ 0.06532937]]
After 0 training step(s), cross entropy on all data is 1.89805 After 1000
training step(s), cross entropy on all data is 0.655075 After 2000 training
step(s), cross entropy on all data is 0.626172 After 3000 training step(s),
cross entropy on all data is 0.615096 After 4000 training step(s), cross
entropy on all data is 0.610309 [[ 0.02476974 0.56948686 1.6921943 ]
[-2.1977353 -0.23668927 1.1143897 ]] [[-0.45544702] [ 0.49110925] [-0.98110336]]

*

*

* tf.train.MomentumOptimizer
*

*
batchsize：批大小。在深度学习中，一般采用 SGD 训练，即每次训练在训练集中取batchsize个样本训练；

*
iteration：迭代，1 个 iteration 等于使用 batchsize 个样本训练一次；

* 一个迭代 = 一个正向通过 + 一个反向通过
* epoch：迭代次数，1 个 epoch 等于使用训练集中的全部样本训练一次；
* 一个epoch = 所有训练样本的一个正向传递和一个反向传递

100次 iteration，1次 epoch。