tensorflow机器学习实战指南 源代码_小小白TensorFlow机器学习实战基础

一、TensorFlow基本概念

TensorFlow以数据流为核心，还具备两大特点：将图的定义和图的运行完全分开；图的计算在会话中执行。具体操作如下：

import tensorflow as tf
# 创建图
a=tf.constant(3,tf.float32,shape=[32])
b=tf.constant(4,tf.float32)
c=tf.constant(5,tf.float32)
# 创建会话
sess=tf.Session()
# 计算
print(sess.run(a))
sess.close()

1、Tensor

Tensor即张量，是最基本的概念，也是Tensor Flow中最主要的数据结果。

基本类型有：

由两个32位浮点数组成的复数：实数和虚数

用于量化操作的32位有符号整数

用于量化操作的8位无符号整型

张量生成方式有很多种，固定张量、相似张量、序列张量和分布函数张量，具体实现如下：

# Tensor概述
import tensorflow as tf
row=3.0
col=4.0
# 值为0，指定维度的张量
zero_tsr=tf.zeros([row,col])
# 值为1，指定维度的张量
ones_tsr=tf.ones([row,col])
# 指定填充数值2.0
filed_tsr=tf.fill([3,4],2.0)
# 已知常数张量
constant_tsr=tf.constant([1,2,3])
# 所有元素为0，与constant_tsr类型已知的张量
zeros_similar=tf.zeros_like(constant_tsr)
# 所有元素为1，与constant_tsr类型已知的张量
ones_similar=tf.ones_like(constant_tsr)
# 创建指定区间，等间距的张量
liner_tsr=tf.linspace(start=0.0,stop=2.0,num=3)
# 创建指定区间，间距的张量
# 该数字序列开始于 start 并且将以 delta 为增量扩展到不包括 limit 时的最大值结束，类似python的range函数。
integer_seq_str=tf.range(start=0,limit=5,delta=1)
# 创建均匀分布随机数的张量
randunif_tsr=tf.random_uniform([3,4],minval=0,maxval=2)
# 创建正态分布随机数的张量
# mean: 正态分布的均值，默认为0;
# stddev: 正态分布的标准差，默认为1.0;
# dtype: 输出的类型，默认为tf.float32;
# seed: 随机数种子，是一个整数，当设置之后，每次生成的随机数都一样; 
# 操作的名称;
randnorm_tsr=tf.random_normal([3,4],mean=0.0,stddev=1.0)
# 创建指定边界的正态分布张量
# 这是一个截断的产生正太分布的函数，就是说产生正太分布的值如果与均值的差值大于两倍的标准差，那就重新生成。
# 和一般的正太分布的产生随机数据比起来，这个函数产生的随机数与均值的差距不会超过两倍的标准差，但是一般的别的函数是可能的。
runcnorm_tsr=tf.truncated_normal([3,4],mean=0.0,stddev=1.0)

# 创建会话
sess=tf.Session()
# 计算
print("zero_tsrn",sess.run(zero_tsr))
print("ones_tsrn",sess.run(ones_tsr))
print("filed_tsrn",sess.run(filed_tsr))
print("constant_tsrn",sess.run(constant_tsr))
print("zeros_similarn",sess.run(zeros_similar))
print("ones_similarn",sess.run(ones_similar))
print("liner_tsrn",sess.run(liner_tsr))
print("integer_seq_strn",sess.run(integer_seq_str))
print("randunif_tsrn",sess.run(randunif_tsr))
print("randnorm_tsrn",sess.run(randnorm_tsr))
print("runcnorm_tsrn",sess.run(runcnorm_tsr))
sess.close()

2、Variable

通过调整这些变量优化机器学习。使用

函数，通过输入一个张量，返回一个变量。变量声明后需要进行初始化才能使用

tensor=tf.zeros([1,2])
# 声明变量
m_var=tf.Variable(tensor)
init_op=tf.global_variables_initializer()
with tf.Session() as sess:
    print('tensor is',sess.run(tensor))
    # print('m_var first is',sess.run(m_var))
    sess.run(init_op)
    print('m_var second is',sess.run(m_var))

3、Placeholder

用于表示输入输出数据的格式，允许传入指定类型和形状的数据。占位符仅仅声明了数据位置。

x=tf.placeholder(tf.float32)
y=tf.placeholder(tf.float32)
z=tf.add(x,y)
with tf.Session() as sess:
    # feed_dict的作用是给使用placeholder创建出来的tensor赋值
    print(sess.run([[z]],feed_dict={x:[1.0,2.0],y:[10.0,11.0]}))

4、Operation

是

图中的节点，他的输入输出都是

。它用于完成各种操作，包括运算操作、矩阵操作和神经网络构建操作等。

5、Queue

主要包含入列(

)和出列(

)两个操作。

操作返回计算图中的一个

节点，

操作返回一个

值，需要放在

中运行才可以获取真正的数值。

顺序出列：

随机顺序出列的队列

import tensorflow as tf
# 声明顺序队列或随机顺序出列的队列
# q=tf.FIFOQueue(10,"float")
# 最大长度10,最小长度2,类型float的随机队列
q=tf.RandomShuffleQueue(capacity=10, min_after_dequeue=0, dtypes="float")
init=q.enqueue_many(([1.0,2.0,3.0,4.0,5.0,6.0],))
with tf.Session() as sess:
    sess.run(init)
    queue=sess.run(q.size())
    for i in range(queue):
        print('q',sess.run(q.dequeue()))

对于一个队列长度为10，出队后最小长度为2的队列，实现如下：

import tensorflow as tf
# 声明顺序队列或随机顺序出列的队列
# q=tf.FIFOQueue(10,"float")
# 最大长度10,最小长度2,类型float的随机队列
q=tf.RandomShuffleQueue(capacity=10, min_after_dequeue=0, dtypes="float")
init=q.enqueue_many(([1.0,2.0,3.0,4.0,5.0,6.0],))
# 定义3s超时
run_options=tf.RunOptions(timeout_in_ms=10000)
with tf.Session() as sess:
    sess.run(init)
    queue=sess.run(q.size())
    for i in range(queue):
        try:
            print('q''''''',sess.run(q.dequeue(), options=run_options))
        except tf.errors.DeadlineExceededError:
            print("Timeout")

6、QueueRunner

即队列管理器，包括CPU、GPU、内存以及读取数据时计算机使用的其他硬件资源。

创建

需要使用方法

表示指定操作，一般是多个操作，每个操作都是一个线程。

使用方法

来完成线程的创建

例如：创建一个队列管理器，进行两个操作。一个操作完成计数器的自增，另一个操作将计数器的值入队。

import tensorflow as tf
# 声明顺序队列或随机顺序出列的队列
q=tf.FIFOQueue(10,"float")
counter=tf.Variable(0.0)
# 给计数器+1
increment_op=tf.assign_add(counter,1.0)
# 将计数器加入队列
enqueue_op=q.enqueue(counter)
# 创建两个操作的进程，*1表示一个操作拥有一个线程
qr=tf.train.QueueRunner(q,enqueue_ops=[increment_op,enqueue_op]*1)
with tf.Session() as sess:
    sess.run(tf.global_variables_initializer())
    qr.create_threads(sess,start=True)
    for i in range(8):
        print(sess.run(q.dequeue()))

7、Coordinator

处理线程间的同步，在线程创建时，指定一个协调器，当主线程完成操作后，使用

方法，通知所有线程停止当前线程，并等待其他线程结束后返回结果。具体实现如下：

import tensorflow as tf
# 声明顺序队列或随机顺序出列的队列
q=tf.FIFOQueue(10,"float")
counter=tf.Variable(0.0)
# 给计数器+1
increment_op=tf.assign_add(counter,1.0)
# 将计数器加入队列
enqueue_op=q.enqueue(counter)
coord=tf.train.Coordinator()
# 创建两个操作的进程，*1表示一个操作拥有一个线程
qr=tf.train.QueueRunner(q,enqueue_ops=[increment_op,enqueue_op]*1)
with tf.Session() as sess:
    sess.run(tf.global_variables_initializer())
    # 对进程指定协调器
    queue_thread=qr.create_threads(sess,coord=coord,start=True)
    for i in range(8):
        print(sess.run(q.dequeue()))
    # 通知线程关闭
    coord.request_stop()
    # 等待线程结束
    coord.join(queue_thread)

相关代码GitHub：

GXL-ops/MachineLearning​github.com