Tensorflow基础知识整理

最新推荐文章于 2021-02-19 12:17:52 发布

键盘里的青春

最新推荐文章于 2021-02-19 12:17:52 发布

阅读量516

点赞数 2

分类专栏： Tensorflow

本文链接：https://blog.csdn.net/qq_34374664/article/details/80651088

版权

Tensorflow 专栏收录该内容

2 篇文章 0 订阅

订阅专栏

参考：寒小阳 茁壮小草

基本语法

1.Tensorflow

首先提提Tensorflow和theano，它俩都是python封装的深度学习库，非常容易上手，说起来Tensorflow还是受Theano启发，借鉴了一部分它的思想。不同之处在于，Tensorflow 对分布式系统支持更好，同时还是Google提供资金研发的，而Theano 是一个学术性质的项目。

Tensorflow 可以对定义在张量(tensors,你可以先简单理解成标量、向量或者矩阵，一会儿会提到)上的函数自动求导，因此神经网络中BP算法可以很轻松地实现。

在开始Tensorflow之前，需要先让大家对Tensorflow的过程有个直观的理解。

在Tensorflow里：

使用张量(tensor)表示数据.
使用图(graph)来表示计算任务.
在被称之为会话(Session)的上下文 (context)中执行图.
通过变量 (Variable)维护状态.
使用feed和fetch可以为任意的操作(arbitrary operation)赋值或者从其中获取数据.

严格意义上来说TensorFlow算是一个编程系统，它使用图来表示计算任务，图中的节点被称之为operation(可以缩写成op)，一个节点获得0个或者多个张量(tensor，下文会介绍到)，执行计算，产生0个或多个张量。TensorFlow的一个图描述了一个计算过程，为了进行计算，图必须在会话(Session)里被启动，会话(Session)将图的op分发到CPU或GPU之类的设备上，同时提供执行op的方法，这些方法执行后，将产生的张量(tensor)返回。返回的张量因语言不同而有不同，在python里是numpy ndarry对象；在C/C++语言中，是tensorflow::Tensor实例。

下面咱们来详细说说上面提到的概念。

1.1 什么是张量

既然Tensorflow里面的定义和运算都是基于张量这个概念，我们就先来看看，什么是张量。

张量的正式定义：从向量空间到实数域的多重现性映射(multilinear maps)（VV是向量空间，V∗V∗是对偶空间）
- f:V∗×⋯V∗p copies×V×⋯Vq copies→Rf:V∗×⋯V∗⏟p copies×V×⋯V⏟q copies→R
- 标量是张量(f:R→R,f(e1)=cf:R→R,f(e1)=c)（译者注: 标量是用实数表示零维空间的点）
- 向量是张量(f:Rn→R,f(ei)=vif:Rn→R,f(ei)=vi)（译者注: 向量是用实数表示一维空间的点，也即向量中的某个元素）
- 矩阵是张量( f:Rn×Rm→R,f(ei,ej)=Aijf:Rn×Rm→R,f(ei,ej)=Aij)（译者注: 矩阵是用实数表示二维空间的点，也即矩阵的某个元素）
- 通常来说，张量可以用多维数组来表示

1.2 Tensorflow 与 Numpy

看似差别甚远的2个package，说起来可能也很少有人把这两者作对比，但他们“长得”确实很相似（都是提供N维数组的库）
Numpy 有 Ndarray(N维数组) 支持，但不提供创建张量函数和自动求导的方法，也不提供GPU支持

1.3 Numpy 与 Tensorflow 定义与操作对比

# numpy定义与操作
In [23]: import numpy as np
In [24]: a = np.zeros((2,2)); b = np.ones((2,2))
In [25]: np.sum(b, axis=1)
Out[25]: array([ 2.,  2.])
In [26]: a.shape
Out[26]: (2, 2)
In [27]: np.reshape(a, (1,4))
Out[27]: array([[ 0.,  0.,  0.,  0.]])

# 对应的Tensorflow定义与操作
In [31]: import tensorflow as tf
In [32]: tf.InteractiveSession()
In [33]: a = tf.zeros((2,2)); b = tf.ones((2,2))
In [34]: tf.reduce_sum(b, reduction_indices=1).eval()
Out[34]: array([ 2.,  2.], dtype=float32)
In [35]: a.get_shape()
Out[35]: TensorShape([Dimension(2), Dimension(2)])
In [36]: tf.reshape(a, (1, 4)).eval()
Out[36]: array([[ 0.,  0.,  0.,  0.]], dtype=float32)

以上代码中提到的 session和.eval()将在下文细述，而关于TensorShape，大家可以简单理解成类似Python中tuple的类型。

为了方便记忆，我们把numpy和Tensorflow中的部分定义和操作做成了一张一一对应的表格，方便大家查看。

Numpy	Tensorflow
a = np.zeros((2,2)); b = np.ones((2,2))	a = tf.zeros((2,2)), b = tf.ones((2,2))
np.sum(b, axis=1)	tf.reduce_sum(a,reduction_indices=[1])
a.shape	a.get_shape()
np.reshape(a, (1,4))	tf.reshape(a, (1,4))
b*5+1	b*5+1
np.dot(a,b)	tf.matmul(a, b)
a[0,0], a[:,0], a[0,:]	a[0,0], a[:,0], a[0,:]

Tensorflow的输出要稍微注意一下，我们需要显式地输出(evaluation，也就是说借助eval()函数)！

In [37]: a = np.zeros((2,2))
In [38]: ta = tf.zeros((2,2))
In [39]: print(a)
[[ 0.  0.]
 [ 0.  0.]]
In [40]: print(ta)
Tensor("zeros_1:0", shape=(2, 2), dtype=float32)
In [41]: print(ta.eval())
[[ 0.  0.]
[ 0. 0.]]

上面是一个示例的代码，大家可以理解Tensorflow是通过计算图（computation graph）定义一个计算过程的，这个过程不产生数值结果，那想看到具体内容怎么办呢？我们要借助.eval()函数输出。

1.4 Tensorflow 的计算图

用Tensorflow编写的程序一般由两部分构成，一是构造部分，包含了计算流图，二是执行部分，通过session 来执行图中的计算，具体可以参考Tensorflow文档

我们先来看看怎么构建图。构件图的第一步是创建源节点(source op)。源节点不需要任何输入，它的输出传递给其它节点(op)做运算。python库中，节点构造器的返回值即当前节点的输出，这些返回值可以传递给其它节点(op)作为输入。

TensorFlow Python库中有一个默认图(default graph)，在默认图的基础上，节点构造器(op 构造器)可以为其增加节点。这个默认图对许多程序来说已经足够用了，更多管理视图的细节可以阅读官方Graph类文档。

我们来看一个简单的构建图例子：

import tensorflow as tf
# 创建一个常量节点， 产生一个1x2矩阵，这个op被作为一个节点
# 加到默认视图中
# 构造器的返回值代表该常量节点的返回值
matrix1 = tr.constant([[3., 3.]])

# 创建另一个常量节点, 产生一个2x1的矩阵
matrix2 = tr.constant([[2.], [2.]])

# 创建一个矩阵乘法matmul节点，把matrix1和matrix2作为输入：
product = tf.matmul(matrix1, matrix2)

上面代码里的默认图现在有三个节点，两个constant()节点和matmul() 节点。不过这仅仅是构建图，为了真正进行矩阵的乘法，你必须在会话(Session，马上提到)里启动这个图。

1.5 Tensorflow与Session对象

上面我们知道了Tensorflow需要先构造一个图用于计算，但是图怎么启动呢？启动图的第一步需要创建一个Session对象。比如：

# 创建session，启动默认图
sess = tf.Session()

# 调用sess的'run()' 方法来执行矩阵乘法节点操作，传入'product'作为该方法的参数。'product'代表了矩阵乘法节点的输出，传入它是告诉方法我们希望取回矩阵乘法节点的输出。

#整个执行过程是自动化的，会话负责传递节点所需的全部输入。节点通常是并发执行的。

# 函数调用'run(product)'会触发图中三个节点（上面例子里提到的两个常量节点和一个矩阵乘法节点）的执行。

# 返回值'result'是一个numpy 'ndarray'对象。

result = sess.run(product)
print result
# 结果为[[12.]]

# 完成任务，记得关闭会话
sess.close()

Session对象在使用完成后，记得关闭以释放资源，当然，除了显式调用close关闭外，也可以使用with代码来自动完成关闭动作：

# 用with代码来自动完成session里的图运算并关闭
with tf.Session() as sess:
  result = sess.run([product])
  print result

为了便于使用像IPython这样的python交互环境，可以使用InteractiveSession代替Session类，使用Tensor.eval()和Operation.run()方法代替Session.run()。这样做的好处是可以在ipython中保持默认session处于打开状态：

# 进入一个交互式Tensorflow会话
import tensorflow as tf
sess = tf.InteractiveSession()

x = tf.Variable([1.0, 2.0])
a = tf.constant([3.0, 3.0]);

# 使用初始化器的run()方法初始化x
x.initializer.run()

# 增加一个减法节点，从x减去a。运行减法op，输出结果
sud = tf.sub(x, a)
print sub.eval()
# 结果为[-2. -1.]

1.6 关于session和多GPU运算

我们一直在说，Tensorflow是支持分布式的深度学习框架/包，这是因为它能将图定义转换成分布式执行的操作，以充分利用可以利用的计算资源（如CPU或GPU）。不过一般情况下，你不需要显式指定使用CPU还是GPU，Tensorflow能自动检测。如果检测到GPU，Tensorflow会优先使用找到的第一个GPU来执行操作。

如果机器上有超过一个可用的GPU，默认状况下除了第一个外的其他GPU是不参与计算的。为了让Tensorflow使用这些GPU，你必须将节点运算明确地指派给它们执行。其中with…Device语句用来指派特定的CPU或GPU操作：

# 手动指定给某个gpu执行
with tf.Session() as sess:
  with tf.device("/gpu:1"):
    matrix1 = tf.constant([[3., 3.]])
    matrix2 = tf.constant([[2.], [2.]])
    product = tf.matmul(matrix1, matrix2)

指定设备的书写格式如下：

/cpu:0:机器的CPU
/gpu:0:机器的第一个GPU，如果有的话
/gpu:1:机器的的第二个GPU，其他GPU以此类推

1.7 Tensorflow的变量(Variables)

我们训练一个模型的时候，会用到Tensorflow中的变量(Variables)，我们需要它来保持和更新参数值，和张量一样，变量也保存在内存缓冲区当中。

有很多同学会问，前面不是提到了一个概念叫做张量，为什么还需要这个新的变量呢？需要说明一下的是，如果大家仔细看之前的代码，会发现我们所用到的张量都是常值张量(constant tensors)，而非变量，而参数值是需要动态调整的内容。

比如下面的代码里我们设定了一组权重为变量：

In [32]: W1 = tf.ones((2,2))
In [33]: W2 = tf.Variable(tf.zeros((2,2)), name="weights")
In [34]: with tf.Session() as sess:
           print(sess.run(W1))
           sess.run(tf.initialize_all_variables())
           print(sess.run(W2))
   ....:
[[ 1.  1.]
 [ 1.  1.]]
[[ 0.  0.]
[ 0. 0.]]

说一个小细节，注意到上面第34步tf.initialize_all_variables，我们要预先对变量初始化(initialization)
Tensorflow 的变量必须先初始化然后才有值！而常值张量是不需要的

再具体一点，比如下面的代码，其实38和39步，我们初始化定义初值是可以通过常数或者随机数等任何一种方式初始化的，但是直到第40步才真正通过Tensorflow的initialize_all_variables对这些变量赋初值。

In [38]: W = tf.Variable(tf.zeros((2,2)), name="weights")
In [39]: R = tf.Variable(tf.random_normal((2,2)), name="random_weights")
In [40]: with tf.Session() as sess:
   ....:     sess.run(tf.initialize_all_variables())
   ....:     print(sess.run(W))
   ....:     print(sess.run(R))
   ....:

比如我们来看一个计算图中变量的状态更新过程，代码如下：

In [63]: state = tf.Variable(0, name="counter")
In [64]: new_value = tf.add(state, tf.constant(1))
In [65]: update = tf.assign(state, new_value)
In [66]: with tf.Session() as sess:
    sess.run(tf.initialize_all_variables())
    print(sess.run(state))
    for _ in range(3):
        sess.run(update)
        print(sess.run(state))
0
1
2
3

上面的代码定义了一个如下的计算图，同时其中变量的状态是循环变化的：*

开始sess.run(tf.initialize_all_variables()) (e.g. state=0)sess.run(update) (e.g. state = new_value = state+1)循环结束？结束yesno

1.8 Tensorflow的Fetch(获取)操作

如果想取回定义的计算图中的节点运算输出结果，可以在使用Session对象的run()调用执行图时，传入一些张量，这些张量可以帮助你取回结果。而且不仅仅是单个节点的状态或者结果，可以输出多个节点的结果，比如下面这个简单例子：

input1 = tf.constant(3.0)
input2 = tf.constant(4.0)
input3 = tf.constant(5.0)
intermed = tf.add(input2, input3)
mul = tf.mul(input1, intermed)

with tf.Session() as sess:
  result = sess.run([mul, intermed])
  print result

# print
# 输出最后的乘法结果，和之前的加法结果[27.0, 9.0]

1.9 Tensorflow与Feed(传入)操作

1.8里我们提到了在计算图中引入张量，以获取节点状态或者输出结果。Tensorflow还提供了feed机制，该机制可以临时替代图中的任意操作中的张量，也就是说，可以对图中任何操作提交补丁，直接插入一个新的张量。

feed可以使用一个张量值临时替换某个操作的输出结果，你只需要提供feed数据作为run()调用的参数。需要说明的是，feed只在调用它的方法内有效，方法结束则feed就会消失。最常见的用例是将某些特殊的操作指定为feed操作，标记的方法是使用tf.placeholder()为这些操作创建占位符(可以先想成一个容器，这个在之后的内容里会提到，不要着急)。

input1 = tf.placeholder(tf.types.float32)
input2 = tf.placeholder(tf.types.float32)
output = tf.mul(input1, input2)

# 手动提供feed数据作为run的参数
with tf.Session() as see:
  print sess.run([output], feed_dict={input:[7.]， input2:[2.]})

# print
# 结果是[array([ 14.], dtype=float32)]

random函数

rf.random_normal

产生正态随机分布

格式：tf.random_normal(shape,mean=0.0,stddev=1.0,dtype=tf.float32,seed=None,name=None)

shape定义维度，mean定义均值，stddev定义方差，dtype定义类型，seed定义种子，name定义名称

例子：

import tensorflow as tf
# Create a tensor of shape [2, 3] consisting of random normal values, with mean
# -1 and standard deviation 4.
norm = tf.random_normal(shape=[2, 3], mean=-1, stddev=4)
with tf.Session() as sess:
    print (sess.run(norm))

结果：
[[ -7.80873823 -10.97159195 -11.99345589]
[ 1.79066849 -4.10513306 4.37571764]]

tf.truncated_normal
产生标准正态分布

格式：tf.truncated_normal(shape, mean=0.0, stddev=1.0, dtype=tf.float32, seed=None, name=None)

shape定义维度，mean定义均值，stddev定义方差，dtype定义类型，seed定义种子，name定义名称

例子：

import tensorflow as tf
# Create a tensor of shape [2, 3] consisting of random normal values, with mean
# 0 and standard deviation 1.
norm = tf.truncated_normal(shape=[2,3],mean=0,stddev=1)
with tf.Session() as sess:
    print (sess.run(norm))

结果：
[[ 1.89490759 -1.03072059 0.2172989 ]
[-0.29377019 -0.38990787 -1.09539473]]

tf.random_uniform
产生均匀分布

格式：tf.random_uniform(shape, minval=0.0, maxval=1.0, dtype=tf.float32, seed=None, name=None)

shape定义维度，minval区间最小值，maxval区间最大值，dtype定义类型，seed定义种子，name定义名称

例子：

import tensorflow as tf
# Create a tensor of shape [2, 3] consisting of random uniform values, with minval=1
#  and maxval =3.
norm = tf.random_uniform(shape=[2,3],minval=1,maxval=3)
with tf.Session() as sess:
    print (sess.run(norm))

结果：
[[ 2.73986316 1.50323987 1.64366412]
[ 1.12579513 1.52106118 1.29330397]]

-tf.random_shuffle

随机的交换位置
格式：tf.random_shuffle(value, seed=None, name=None)
value是一个给定的张量，seed定义的种子，name定义名称

例子：

import tensorflow as tf
c = tf.constant([[1,2],[3,4],[5,6]])
shuff = tf.random_shuffle(value=c,seed=1,name="shuff")
with tf.Session() as sess:
    print (sess.run(shuff))

结果：
[[1 2]
[5 6]
[3 4]]

tf.set_random_seed

设置种子
格式：tf.set_random_seed(seed)
seed是给定的种子

例子：

import tensorflow as tf
tf.set_random_seed(1234)
a = tf.random_uniform([1])
b = tf.random_normal([1])
with tf.Session() as sess:
    print (sess.run(a))
    print (sess.run(b))

结果：
[ 0.59309709]
[ 0.32048994]

每次运行结果都不一致。要一致还是在定义张量的内部来设置。

序列张量（Sequences）

tf.linspace

产生序列张量
格式：tf.linspace(start,stop,num,name=None)
start定义起始值，stop定义最后的值，num定义数量，name定义类型

例子：

tf.linspace(10.0, 12.0, 3, name="linspace") => [ 10.0  11.0  12.0]

tf.range

定义序列值，类似与range
格式：tf.range(start,limit,delta=1,name=’range’)

start定义起始值，limit定义最大的上限（不包括limit的值），delta定义间隔值，name定义名称

例子：

# 'start' is 3
# 'limit' is 18
# 'delta' is 3
tf.range(start, limit, delta) ==> [3, 6, 9, 12, 15]

常用函数

数值乘法mul

例如：a=3，b=3，a*b = 9

import tensorflow as tf
a = tf.placeholder(tf.float32)
b = tf.placeholder(tf.float32)
y = tf.mul(a, b)
sess = tf.Session() 
print (sess.run(y, feed_dict={a: 3, b: 3}))

结果：9.0

数值和add

例如: a = 3, b=3 ,a+b = 6

import tensorflow as tf
a = tf.placeholder(tf.float32)
b = tf.placeholder(tf.float32)
y = tf.add(a, b)
sess = tf.Session() 
print (sess.run(y, feed_dict={a: 3, b: 3}))

结果：6.0

数值减法sub

例如：a=3,b=3,a-b = 0

import tensorflow as tf
a = tf.placeholder(tf.float32)
b = tf.placeholder(tf.float32)
y = tf.sub(a, b)
sess = tf.Session() 
print (sess.run(y, feed_dict={a: 3, b: 3}))

结果： 0.0

数值除法div

例如: a=3,b=3,a/b = 1.0

import tensorflow as tf
a = tf.placeholder(tf.float32)
b = tf.placeholder(tf.float32)
y = tf.div(a, b)
sess = tf.Session() 
print (sess.run(y, feed_dict={a: 3, b: 3}))

结果: 1.0

数值取模mod

例如:a=3,b=3,a mod b = 0

import tensorflow as tf
a = tf.placeholder(tf.float32)
b = tf.placeholder(tf.float32)
y = tf.mod(a, b)
sess = tf.Session() 
print (sess.run(y, feed_dict={a: 3, b: 3}))

结果: 0.0

数值绝对值abs

例如:a=-3, abs (a) = 3

import tensorflow as tf
a = tf.placeholder(tf.float32)
b = tf.placeholder(tf.float32)
y = tf.abs(a)
sess = tf.Session() 
print (sess.run(y, feed_dict={a: -3}))

结果： 3.0

数值非负值neg

例如:a=-3, neg (a) = 3

import tensorflow as tf
a = tf.placeholder(tf.float32)
y = tf.neg(a)
sess = tf.Session() 
print (sess.run(y, feed_dict={a: -3}))

结果： 3.0

数值符号函数sign

例如:a=-3, neg (a) = 3

import tensorflow as tf
a = tf.placeholder(tf.float32)
y = tf.neg(a)
sess = tf.Session() 
print (sess.run(y, feed_dict={a: -3}))

结果： 3.0

数值符号函数sign

例如: a=-3,sign(a) = -1

import tensorflow as tf
a = tf.placeholder(tf.float32)
y = tf.sign(a)
sess = tf.Session() 
print (sess.run(y, feed_dict={a: -3}))

结果: -1.0

数值倒数inv

例如: a=-3,sign(a) = -1

import tensorflow as tf
a = tf.placeholder(tf.float32)
y = tf.sign(a)
sess = tf.Session() 
print (sess.run(y, feed_dict={a: -3}))

数值平方square

例如: a=-3,square(a) = 9

import tensorflow as tf
a = tf.placeholder(tf.float32)
y = tf.square(a)
sess = tf.Session() 
print (sess.run(y, feed_dict={a: -3}))

结果: 9.0

数值最近的整数round

例如: a=-3.6,round(a) = -4.0

import tensorflow as tf
y = tf.round(a)
sess = tf.Session() 
print (sess.run(y, feed_dict={a: -3.6}))

结果: -4.0

例如: a=-3.3,round(a) = -3.0

import tensorflow as tf
y = tf.round(a)
sess = tf.Session() 
print (sess.run(y, feed_dict={a: -3.3}))

结果：-3.0

数值平方根sqrt

例如: a=4,sqrt(a) = 2

import tensorflow as tf
a = tf.placeholder(tf.float32)
y = tf.sqrt(a)
sess = tf.Session() 
print (sess.run(y, feed_dict={a: 4}))

结果: 2.0

数值幂次pow

例如: a=2,b=3,pow(a,b) = 8

import tensorflow as tf
a = tf.placeholder(tf.float64)
b = tf.placeholder(tf.float64)
y = tf.pow(a, b)
sess = tf.Session() 
print (sess.run(y, feed_dict={a: 2, b: 3}))

结果: 8.0

数值最近的整数exp

例如: a=2,exp(a) = 7.38906

import tensorflow as tf
a = tf.placeholder(tf.float32)
y = tf.exp(a)
sess = tf.Session() 
print (sess.run(y, feed_dict={a: 2}))

结果: 7.38906

数值取对数log

例如: a=-3.6,round(a) = -4.0

import tensorflow as tf
a = tf.placeholder(tf.float32)
y = tf.log(a)
sess = tf.Session() 
print (sess.run(y, feed_dict={a: 2}))

结果: 0.69314718056

数值取最大值maximum

例如: a=-3.6, b = 2,maximum(a,b)=2

import tensorflow as tf
a = tf.placeholder(tf.float32)
b = tf.placeholder(tf.float32)
y = tf.maximum(a,b)
sess = tf.Session() 
print (sess.run(y, feed_dict={a: -3.6,b: 2}))

结果: 2.0

数值最小值minimum

例如: a=2,b=3minimum(a) = 3

import tensorflow as tf
a = tf.placeholder(tf.float64)
b = tf.placeholder(tf.float64)
y = tf.minimum(a, b)
sess = tf.Session() 
print (sess.run(y, feed_dict={a: 2, b: 3}))

结果: 2.0

数值余弦函数cos

例如: a=2,cos(a) = -0.416146836547

import tensorflow as tf
a = tf.placeholder(tf.float64)
y = tf.cos(a)
sess = tf.Session() 
print (sess.run(y, feed_dict={a: 2}))

结果: -0.416146836547

数值正弦函数sin

例如: a=2,sin(a) = -0.416146836547

import tensorflow as tf
a = tf.placeholder(tf.float64)
y = tf.sin(a)
sess = tf.Session() 
print (sess.run(y, feed_dict={a: 2}))

结果: 0.909297426826

纬度转换

shape 计算维度

tf.shape(input,name = None)

案例1

a = tf.constant([i for i in range(20)],shape =[2,2,5])
with tf.Session() as sess:
    print (sess.run(tf.shape(a)))

结果：[2 2 5]

size 计算元素个数

tf.size(input,name = None)

案例2

a = tf.constant([i for i in range(20)],shape =[2,2,5])
with tf.Session() as sess:
    print (sess.run(tf.size(a)))

结果：20

rank 计算秩

tf.rank(input, name=None)

案例3

a = tf.constant([i for i in range(20)],shape =[2,2,5])
with tf.Session() as sess:
    print (sess.run(tf.rank(a)))

结果： 3

reshape重新的规则排列

tf.reshape(tensor, shape, name=None)

案例4

a = tf.constant([i for i in range(20)],shape =[2,2,5])
with tf.Session() as sess:
    print (sess.run(tf.reshape(a,shape = [5,2,2])))

原始的数据
这里写图片描述
结果：

squeeze

没理解，等理解了再来更新。

tf.squeeze(input, squeeze_dims=None, name=None)

expand_dims

没理解，等理解了再来更新。

tf.expand_dims(input, dim, name=None)

读取csv文件

方法一：
以一个案例来切入：

#加载包
from __future__ import absolute_import
from __future__ import division
from __future__ import print_function

import tensorflow as tf
import numpy as np

# 数据集名称，数据集要放在你的工作目录下
IRIS_TRAINING = "iris_training.csv"
IRIS_TEST = "iris_test.csv"

# 数据集读取，训练集和测试集
training_set = tf.contrib.learn.datasets.base.load_csv_with_header(
    filename=IRIS_TRAINING,
    target_dtype=np.int,
    features_dtype=np.float32)
test_set = tf.contrib.learn.datasets.base.load_csv_with_header(
    filename=IRIS_TEST,
    target_dtype=np.int,
    features_dtype=np.float32)

# 特征
feature_columns = [tf.contrib.layers.real_valued_column("", dimension=4)]

# 构建DNN网络，3层，每层分别为10,20,10个节点
classifier = tf.contrib.learn.DNNClassifier(feature_columns=feature_columns,
                                            hidden_units=[10, 20, 10],
                                            n_classes=3,
                                            model_dir="/tmp/iris_model")

# 拟合模型，迭代2000步
classifier.fit(x=training_set.data,
               y=training_set.target,
               steps=2000)

# 计算精度
accuracy_score = classifier.evaluate(x=test_set.data,y=test_set.target)["accuracy"]

print('Accuracy: {0:f}'.format(accuracy_score))

# 预测新样本的类别
new_samples = np.array([[6.4, 3.2, 4.5, 1.5], [5.8, 3.1, 5.0, 1.7]], dtype=float)
y = list(classifier.predict(new_samples, as_iterable=True))
print('Predictions: {}'.format(str(y)))

结果好长，给出关键的部分：
INFO:tensorflow:Saving evaluation summary for step 12001: accuracy = 0.966667, loss = 0.461221
Accuracy: 0.966667

预测结果：
Predictions: [1, 1]

从上面的代码可以发现，读取方式为：

training_set = tf.contrib.learn.datasets.base.load_csv_with_header(
    filename=IRIS_TRAINING,
    target_dtype=np.int,
    features_dtype=np.float32)
test_set = tf.contrib.learn.datasets.base.load_csv_with_header(
    filename=IRIS_TEST,
    target_dtype=np.int,
    features_dtype=np.float32)

IRIS_TRAINING ：训练集
IRIS_TEST：测试集

特征提取：

# 特征
feature_columns = [tf.contrib.layers.real_valued_column("", dimension=4)]

完整的代码见github:https://github.com/zhangdm/machine-learning-summary/tree/master/tensorflow/tensorflow_read_csv_DNN

方法二：

#加载包
import tensorflow as tf
import os

#设置工作目录
os.chdir("你自己的目录")
#查看目录
print(os.getcwd())

#读取函数定义
def read_data(file_queue):
    reader = tf.TextLineReader(skip_header_lines=1)
    key, value = reader.read(file_queue)
    #定义列
    defaults = [[0], [0.], [0.], [0.], [0.], ['']]
 #编码   Id,SepalLengthCm,SepalWidthCm,PetalLengthCm,PetalWidthCm,Species = tf.decode_csv(value, defaults)

    #处理
    preprocess_op = tf.case({
        tf.equal(Species, tf.constant('Iris-setosa')): lambda: tf.constant(0),
        tf.equal(Species, tf.constant('Iris-versicolor')): lambda: tf.constant(1),
        tf.equal(Species, tf.constant('Iris-virginica')): lambda: tf.constant(2),
    }, lambda: tf.constant(-1), exclusive=True)

    #栈
    return tf.stack([SepalLengthCm,SepalWidthCm,PetalLengthCm,PetalWidthCm]), preprocess_op


def create_pipeline(filename, batch_size, num_epochs=None):
    file_queue = tf.train.string_input_producer([filename], num_epochs=num_epochs)
    example, label = read_data(file_queue)

    min_after_dequeue = 1000
    capacity = min_after_dequeue + batch_size
    example_batch, label_batch = tf.train.shuffle_batch(
        [example, label], batch_size=batch_size, capacity=capacity,
        min_after_dequeue=min_after_dequeue
    )

    return example_batch, label_batch

x_train_batch, y_train_batch = create_pipeline('Iris-train.csv', 50, num_epochs=1000)
x_test, y_test = create_pipeline('Iris-test.csv', 60)
print(x_train_batch,y_train_batch)

结果：
Tensor(“shuffle_batch_2:0”, shape=(50, 4), dtype=float32) Tensor(“shuffle_batch_2:1”, shape=(50,), dtype=int32)

从它的数据维度可知，数据已经读入。

一个完整的例子见github：https://github.com/zhangdm/machine-learning-summary/tree/master/tensorflow/tensorflow_iris_nn