系统架构

运算

正常的运算

t=7+8
print(t)

tensorflow计算方式好像不太一样，需要先写好数据流图，需要用session去执行这个图，

import tensorflow as tf
import  os
os.environ['TF_CPP_MIN_LOG_LEVEL'] = '2'
sess=tf.Session()

a = tf.constant(10)
b = tf.constant(22)

print(sess.run(a+b))

sess.close()

在 传 统 的 程 序 操 作 中， 定 义 了 t 的 运 算， 在 运 行 时 就 执 行 了， 并 输 出 17。 而 在 TensorFlow 中， 数 据 流 图 中 的 节 点， 实 际 上 对 应 的 是 TensorFlow API 中 的 一 个 操 作， 并 没 有 真 正 去 运 行：

import tensorflow as tf 
t = tf.add( 8, 9) 
print( t) 
# 输 出 Tensor(" Add_1: 0", shape =(), dtype = int32)

节选自：Alexander·T·Combs; Rodolfo·Bonnin; 李嘉璇. 机器学习从认知到实践(第2辑)(套装共3册,Python+TensorFlow) (Kindle 位置 9300-9304). 人民邮电出版社.

数据类型

数 据 类 型	Python 类 型	描 述
DT_FLOAT	tf.float32	32 位 浮 点 型
DT_DOUBLE	tf.float64	64 位 浮 点 型
DT_INT64	tf.int64	64 位 有 符 号 整 型
DT_INT32	tf.int32	32 位 有 符 号 整 型
DT_INT16	tf.int16	16 位 有 符 号 整 型
DT_INT8	tf.int8	8 位 有 符 号 整 型
DT_UINT8	tf.uint8	8 位 无 符 号 整 型
DT_STRING	tf.string	可 变 长 度 的 字 节 数 组， 每 一 个 张 量 元 素 都 是 一 个 字 节 数 组
DT_BOOL	tf.bool	布 尔 型
DT_COMPLEX64	tf.complex64	由 两 个 32 位 浮 点 数 组 成 的 复 数： 实 部 和 虚 部
DT_QINT32	tf.qint32	用 于 量 化[ 9] 操 作 的 32 位 有 符 号 整 型
DT_QINT8	tf.qint8	用 于 量 化 操 作 的 8 位 有 符 号 整 型
DT_QUINT8	tf.quint8	用 于 量 化 操 作 的 8 位 无 符 号 整 型

队列

FIFO先进先出

import tensorflow as tf

# 定义一个能在TensorFlow里运行的先进先出队列，队列长度是3，数据类型是浮点
q = tf.FIFOQueue(3,'float')
# 初始化里面的数据 入队
init = q.enqueue_many(([0.1,0.2,0.3],))
# 取一个出队列。这里其实并没有出去，因为还没放在TensorFlow里运行
x = q.dequeue()

# 定义y 的类型
y = x + 1

# 把y 放进去 q队列 ，这里也算是没有执行
q_inc = q.enqueue([y])
with tf.Session() as sess:
    # 这里才算是初始队列。
    sess.run(init)
    # 计算队列的长度
    quelen = sess.run(q.size())
    for i in range(2):
        # 执行两次q_inc 等于上面写好的类似于函数，需要放在session里去运行
        sess.run(q_inc)
    print('---')
    quelen = sess.run(q.size())
    for i in range(quelen):
        print(sess.run(q.dequeue()))

随机队列

好像是训练时候可以进行无序输入

import tensorflow as tf

# 创建一个随机队列
q = tf.RandomShuffleQueue(capacity=10,min_after_dequeue=2,dtypes='float')

with tf.Session() as sess:
    # 执行10次入队
    for i in range(0,10):
        sess.run(q.enqueue(i))
    # 执行8次出队
    for i in range(0,8):
        print(sess.run(q.dequeue()))

会发现结果是随机出来的

队列控制器

import tensorflow as tf

# 定义一个能在TensorFlow里运行的先进先出队列，队列长度是3，数据类型是浮点
q = tf.FIFOQueue(100, 'float')

# 定义一个计数器变量
counter = tf.Variable(0.0)
# 给计数器+1
increment_op = tf.assign_add(counter, tf.constant(1.0))
# 将计数器放入队列
enqueue_op = q.enqueue([counter])
# 这里是个队列管理器
qr = tf.train.QueueRunner(q, enqueue_ops=[increment_op, enqueue_op] * 1)

with tf.Session() as sess:
    sess.run(tf.global_variables_initializer())
    # 这个是协调器，协调session线程和本地
    coord = tf.train.Coordinator()
    enqueue_threads = qr.create_threads(sess, start=True)
    # 不然会包session错误，
    coord.request_stop()
    for i in range(10):
        print(sess.run(q.dequeue()))
    # 在这里等着队列结束，不然session结束了，队列没结束狂报错
    coord.join(enqueue_threads)