TensorFlow基础

# tensorflow的张量本身并没有存储任何具体的数字，它保存的是得到这些结果的计算过程，
# 保存的是张量的结构（即张量的name，shape和type）

# tf中三类特别的张量
# 张量的生命周期通常随依赖的计算完成而阶数，内存也随即释放
# 变量则常驻内存，在每一步训练时不断更新其值，以实现模型参数的更新
tf.constant          # 常量，一旦被创建，值不可改变
tf.placeholder       # 占位符，可以看做是描述高维数据的一个壳，需要在图外填充数据才能够进行运算
tf.Variable          # 变量，其内存会一直被保存，即使运算完也不会被释放，常用于存储模型参数
# 创建变量
w = tf.Variable(<initial_value>, name=<name>)
# 使用assign或assign_xxx方法重新给变量赋值
w.assign(w + 1.0)
w.assign_add(1.0)

# tf的定义和初始化是不一样的

# 获取一个张量的阶数
rank = tf.rank(<tensor>)   # 阶数描述了一个张量最多可以有多少维

# 定义一个四阶张量
my_image = tf.zeros([10, 64, 64, 3])   # batch x height x width x color

TensorFlow查看一个变量的值：

# 首先必须创建Session会话，必须要在会话中才能打印输出变量的值
print(sess.run(<variable>))

1_1.PNG

Saver的使用：

v1 = tf.Variable(..., name='v1')
v2 = tf.Variable(..., name='v2')
# 指定需要保存和恢复的变量
saver = tf.train.Saver({'v1':v1, 'v2':v2})
# 下面这两种Saver方法是等价的，它们的名字就是v1和v2定义的时候name中的内容
saver = tf.train.Saver([v1, v2])
saver = tf.train.Saver({v.op.name: v for v in [v1, v2]})
# 保存变量的方法。saver方法接收三个变量：sess指明是保存哪个对话的，'my_model'指明
# 模型文件的前缀，global_step是指明了是在当前训练的哪一步保存模型的
tf.train.saver.save(sess, 'my_model', global_step=0) # ==> filename: 'my_model-0'

变量的创建及简单运算：

import tensorflow as tf 

# 创建变量，tf.random_normal方法返回形状为(1, 4)的张量，它的4个元素符合
# 均值为100，标准差为0.35的正态分布
W = tf.Variable(initial_value=tf.random_normal(shape=(1, 4), mean=100, stddev=0.35), name='W')
b = tf.Variable(tf.zeros([4]), name='b')

# 初始化变量
# 创建会话
sess = tf.Session()
# 使用 global_variables_initializer 方法初始化全局变量W和b
sess.run(tf.global_variables_initializer())
# 执行操作，获取变量值
sess.run([W, b])
# 执行更新变量b的操作
sess.run(tf.assign_add(b, [1, 1, 1, 1]))
# 查看b是否更新成功
sess.run(b)

# 创建Saver
saver = tf.train.Saver({'W':W, 'b':b})
# 存储变量到文件 './summary/test.ckpt-0 (ckpt即checkpoint的缩写)
saver.save(sess, './summary/test.ckpt', global_step=0)
# 在summary文件夹中会看到4个文件，其中：
# .data文件存的是变量实际的值
# .meta存的是数据流图的结构
# .index存的是索引，通过该索引可以帮助快速地找回该数据

# 再次执行更新变量b的操作
sess.run(tf.assign_add(b, [1, 1, 1, 1]))
# 获取变量b的最新值
print(sess.run(b))

# 从文件中恢复变量b的值
saver.restore(sess, './summary/test.ckpt-0')
# 查看变量b是否恢复成功
print(sess.run(b))

# 从文件中恢复数据流图结构
# tf.train.import_meta_graph

TensorFlow占位符操作：

TensorFlow使用占位符操作表示图外输入的数据，如训练和测试数据。

数据流图本身只是一个具有计算拓扑和内部结构的“壳”，在用户向数据流图填充数据前，图中并没有真正执行任何计算。

# 占位符的一般定义如下：
x = tf.placeholder(dtype, shape, name)

'''
实例
'''
x = tf.placeholder(tf.int16, shape=(), name='x')
y = tf.placeholder(tf.int16, shape=(), name='y')

# 定义要用到的计算操作
add = tf.add(x, y)
mul = tf.multiply(x, y)

# 加载默认数据流图
with tf.Session() as sess:
    # 填充数据后，执行操作
    print(sess.run(add, feed_dict={x: 2, y: 3}))  # 输出5
    print(sess.run(mul, feed_dict={x: 2, y: 3}))  # 输出6

import tensorflow as tf 

x = tf.placeholder(tf.float32, name='x')
y = tf.placeholder(tf.float32, name='y')
z = tf.multiply(x, y, name='z')

with tf.Session() as sess:
    print(sess.run(z, feed_dict={x:3.0, y:2.0}))  # 输出6.0

TensorFlow的会话：

会话提供了估算张量和执行操作的运行环境，它是发放计算任务的客户端，所有计算任务都由它连接的执行引擎完成。

一个会话的典型流程分为以下三步：

#------------------------ step 1: 创建会话 ------------------------#
# target是会话连接的执行引擎，默认是本地的机器
# graph是会话加载的数据流图，默认加载当前定义的数据流图
# config是会话启动时的配置项
sess = tf.Session(target=..., graph=..., config=...) 

#------------------------ step 2: 估算张量或执行操作 ------------------------#
sess.run(...)

#------------------------ step 3: 关闭会话 ------------------------#
sess.close()

常量操作不需要初始化，变量需要初始化。

获取张量值的两种方法：

###############################################################################
###################          第一种：sess.run()              ###################
###############################################################################
with tf.Session() as sess:
    print(sess.run(z, feed_dict={x:3.0, y:2.0}))
    
###############################################################################
###################             第二种：Tensor.eval()        ###################
###############################################################################
import tensorflow as tf 

# 创建数据流图：y = W * x + b，其中W和b为存储节点，x为数据节点
x = tf.placeholder(tf.float32)
W = tf.Variable(1.0)
b = tf.Variable(1.0)
y = W * x + b
with tf.Session() as sess:
    tf.global_variables_initializer().run()  # Operation.run 
    fetch = y.eval(feed_dict={x: 3.0})       # Tensor.eval
    print(fetch)                             # fetch = 1.0 * 3.0 + 1.0

可以在创建节点时指定执行该节点的设备：

# 在0号CPU执行的存储节点
with tf.device('/cpu:0'):
    v = tf.Variable(...)
    
# 在0号GPU上执行的计算节点
with tf.device('gpu:0'):
    z = tf.matmul(x, y)

TensorFlow优化器：

一次典型的迭代优化应该分为以下3个步骤：

• 1.计算梯度：调用compute_gradients方法；
• 2.处理梯度：根据自己需求处理梯度值，如梯度裁剪和梯度加权；
• 3.应用梯度：调用apply_gradients方法，将处理后的梯度值应用到模型参数。

import tensorflow as tf 

# 1. 计算梯度
# 使用梯度下降优化器，学习率设置为0.01
optimizer = tf.train.GradientDescentOptimizer(learning_rate=0.01)
grads_and_vars = optimizer.compute_gradients(loss, var_list,...)

# 2. 处理梯度
clip_grads_and_vars = [(tf.clip_by_value(grad, -1.0, 1.0), var)
                        for grad, var in grads_and_vars]

# 3. 应用梯度
train_op = optimizer.apply_gradients(clip_grads_and_vars)

如果不需要对梯度进行额外的处理，也可以直接计算并应用梯度到模型参数：

optimizer = tf.train.GradientDescentOptimizer(learning_rate=0.01)
global_step = tf.Variable(0, name='global_step', trainable=False)
train_op = optimizer.minimize(loss, global_step=global_step)

TensorFlow放假预测

线性回归、监督学习

1_2.PNG