【RL从入门到放弃】【二十二】

现在来看看tensorflow，毕竟要在tensorflow和pytorch之间该改改

1、demo

1、variable  2、graph  3、op  4、session  

# -*- coding: utf-8 -*-
import tensorflow as tf;
import numpy as np;


x_data = np.float32(np.random.rand(2,100))
y_data = np.dot([0.1,0.2],x_data)+0.5

b = tf.Variable(tf.zeros([1]))
#random_uniform产生随机值
w = tf.Variable(tf.random_uniform([1,2], -1.0, 1.0))

#tf.matmul（）将矩阵a乘以矩阵b，生成a * b
y = tf.matmul(w,x_data)+b

#最小化方差
loss = tf.reduce_mean(tf.square(y-y_data))
optimizer = tf.train.GradientDescentOptimizer(0.5)
train = optimizer.minimize(loss)

#初始化变量
init = tf.global_variables_initializer()

#启动图
sess = tf.Session()
sess.run(init)

#拟合平面
for step in range(0, 201):
	sess.run(train)
	if step%20==0:
		print(step)
		print(sess.run(w))
		print(sess.run(b))

1、生成常量tensor

tf.zeros([1])

2、生成随机矩阵tensor

w = tf.Variable(tf.random_uniform([1,2], -1.0, 1.0))

3、生成tf变量

w = tf.Variable(tf.random_uniform([1,2], -1.0, 1.0))

b = tf.Variable(tf.zeros([1]))

4、定义optimizer

optimizer = tf.train.GradientDescentOptimizer(0.5)

optimizer是不能放在sess里面进行run的

5、定义会话

tensorflow操作都需要丢到Session里面进行运行

sess = tf.Session()

6、变量的初始化

init = tf.global_variables_initializer()

7、图的计算

print(sess.run(init))

2、helloworld

import tensorflow as tf;

hello = tf.constant("hello world")
sess = tf.Session()
print(sess.run(hello))
sess.close()

1、定义graph 2、定义session  3、将graph丢到session里面去运行

3、tensorflow要素

1、graph

什么是graph：op的执行步骤被描述成一个graph

# -*- coding: utf-8 -*-
import tensorflow as tf;
#创建一个常量op，产生一个1×2的矩阵，常量op被作为一个节点
#加载到default graph中，
#构造器的返回值代表该常量op的返回值
matrix1 = tf.constant([[7,6]])


matrix2 = tf.constant([[4],[5]])

#创建一个矩阵乘法，matul op，把matrix1和matrix2作为输入
#返回值product作为矩阵乘法的结果
product = tf.matmul(matrix1, matrix2)

默认图现在有三个节点，两个 constant() op, 和一个matmul() op。为了真正进行矩阵相乘运算，并得到矩阵乘法的 结果，你必须在会话里启动这个图。

1、创建op，上面的constant就是op，python库中，op构造器的返回值代表构造出的op的输出，

这些返回值可以传递给其余的op作为输入。

2、Tensorflow python含有一个default graph，op构造器可以为他增加节点。

2、session

graph的执行需要被放在session里面即使用session执行graph里面的op：

构造阶段完成后, 才能启动图。启动图的第一步是创建一个 Session 对象，如果无任何创建参数, 会话构造器将启动默认图

#启动default graph
sess = tf.Session()
# 调用 sess 的 'run()' 方法来执行矩阵乘法 op, 传入 'product' 作为该方法的参数. 
# 上面提到, 'product' 代表了矩阵乘法 op 的输出, 传入它是向方法表明, 我们希望取回
# 矩阵乘法 op 的输出.
#
# 整个执行过程是自动化的, 会话负责传递 op 所需的全部输入. op 通常是并发执行的.
# 
# 函数调用 'run(product)' 触发了图中三个 op (两个常量 op 和一个矩阵乘法 op) 的执行.
#
# 返回值 'result' 是一个 numpy `ndarray` 对象.
result = sess.run(product)
print(result)
# 任务完成, 关闭会话.
sess.close()
但是经常没有看到sess.Close这个函数的（显式关闭），使用with的方式的话会自动调用close函数
with tf.Session() as sess:
    result = sess.run([product])
print(result)

在session指定使用cpu还是gpu进行计算，以及使用使用第几个gpu进行执行

在实现上, TensorFlow 将图形定义转换成分布式执行的操作, 以充分利用可用的计算资源(如 CPU 或 GPU). 一般你不需要显式指定使用 CPU 还是 GPU, TensorFlow 能自动检测. 如果检测到 GPU, TensorFlow 会尽可能地利用找到的第一个 GPU 来执行操作.

如果机器上有超过一个可用的 GPU, 除第一个外的其它 GPU 默认是不参与计算的. 为了让 TensorFlow 使用这些 GPU, 你必须将 op 明确指派给它们执行. with...Device 语句用来指派特定的 CPU 或 GPU 执行操作:

with tf.Session() as sess:
    with tf.device("/gpu:1"):
        result = sess.run([product])
        print(result)

设备用字符串进行标识. 目前支持的设备包括:

• "/cpu:0": 机器的 CPU.
• "/gpu:0": 机器的第一个 GPU, 如果有的话.
• "/gpu:1": 机器的第二个 GPU, 以此类推.

3、session.run的交互式替换方法

文档中的 Python 示例使用一个会话 Session 来 启动图, 并调用 Session.run() 方法执行操作.

为了便于使用诸如 IPython 之类的 Python 交互环境, 可以使用 InteractiveSession 代替 Session 类, 使用 Tensor.eval() 和 Operation.run() 方法代替 Session.run(). 这样可以避免使用一个变量来持有会话.

#进入一个交互式tensorflow
sess = tf.InteractiveSession()
x = tf.Variable([[1.0,2.0]])
a = tf.constant([3.0,9.0])
#使用初始化器initializer op的run方法初始化x
x.initializer.run()
sub = tf.subtract(x,a)
# 增加一个减法 sub op, 从 'x' 减去 'a'. 运行减法 op, 输出结果 
print(sub.eval())

4、tensor

TensorFlow 程序使用 tensor 数据结构来代表所有的数据,计算图中, 操作间传递的数据都是 tensor. 你可以把 TensorFlow tensor 看作是一个 n 维的数组或列表. 一个 tensor 包含一个静态类型 rank, 和 一个 shape。

来看看什么是rank和shape

#创建一个变量，初始化为标量0
state = tf.Variable(0, name="counter")

#创建一个op，其作用是使state增加1
one = tf.constant(1)
new_value = tf.add(state, one)
update = tf.assign(state, new_value)

# 启动图后, 变量必须先经过`初始化` (init) op 初始化,
# 首先必须增加一个`初始化` op 到图中.
#之前一直定义的是constant,so  基本上没有使用
init_op = tf.initialize_all_variables()

# 启动图, 运行 op
with tf.Session() as sess:
    # 运行 'init' op
    sess.run(init_op)
    # 打印 'state' 的初始值
    print(sess.run(state))
    # 运行 op, 更新 'state', 并打印 'state'
    for _ in range(2):
        sess.run(update)
        print(sess.run(state))

代码中 assign() 操作是图所描绘的表达式的一部分, 正如 add() 操作一样. 所以在调用 run() 执行表达式之前, 它并不会真正执行赋值操作.

通常会将一个统计模型中的参数表示为一组变量.例如, 你可以将一个神经网络的权重作为某个变量存储在一个 tensor 中.在训练过程中, 通过重复运行训练图, 更新这个 tensor.

5、fetch

为了取回操作的输出内容, 可以在使用 Session 对象的 run() 调用 执行图时, 传入一些 tensor, 这些 tensor 会帮助你取回结果. 在之前的例子里, 我们只取回了单个节点 state, 但是你也可以取回多个 tensor:

input1 = tf.constant(2)
input2 = tf.constant(3)
input3 = tf.constant(4)

intermed = tf.add(input1, input2)
mul = tf.multiply(input1, intermed)#做除法

with tf.Session() as sess:
    result = sess.run([mul, intermed])
print(result)
#需要获取的多个 tensor 值,在 op 的一次运行中一起获得(而不是逐个去获取 tensor).

6、feed

上述示例在计算图中引入了 tensor, 以常量或变量的形式存储. TensorFlow 还提供了 feed 机制, 该机制可以临时替代图中的任意操作中的 tensor 可以对图中任何操作提交补丁, 直接插入一个 tensor.

feed 使用一个 tensor 值临时替换一个操作的输出结果. 你可以提供 feed 数据作为 run() 调用的参数. feed 只在调用它的方法内有效, 方法结束, feed 就会消失. 最常见的用例是将某些特殊的操作指定为 "feed" 操作, 标记的方法是使用 tf.placeholder() 为这些操作创建占位符.

input1 = tf.placeholder(tf.float32)
input2 = tf.placeholder(tf.float32)
output = tf.multiply(input1, input2)

with tf.Session() as sess:
print(sess.run([output], feed_dict={input1:[4.9], input2:[3.0]}))

7、tensorboard

因为TensorFlow是采用数据流图（data　flow　graphs）来计算, 所以首先我们得创建一个数据流流图, 然后再将我们的数据（数据以张量(tensor)的形式存在）放在数据流图中计算. 节点（Nodes）在图中表示数学操作,图中的线（edges）则表示在节点间相互联系的多维数据数组, 即张量（tensor). 训练模型时tensor会不断的从数据流图中的一个节点flow到另一节点, 这就是TensorFlow名字的由来.