tensorflow语法【zip、tf.tile、tf.truncated_normal、tf.data.Dataset.from_tensor_slices、dataset中shuffle()】

相关文章：

【一】tensorflow安装、常用python镜像源、tensorflow 深度学习强化学习教学

【二】tensorflow调试报错、tensorflow 深度学习强化学习教学

【三】tensorboard安装、使用教学以及遇到的问题

【四】超级快速pytorch安装

---

trick1---实现tensorflow和pytorch迁移环境教学

---

zip（）函数

zip语法

zip([iterable, ...])
a=[1,2,3]
b=[4,5,6]
c=[4,5,6,7,8]

zip() 函数用于将可迭代的对象作为参数，将对象中对应的元素打包成一个个元组，然后返回由这些元组组成的列表。如果各个迭代器的元素个数不一致，则返回列表长度与最短的对象相同，利用 * 号操作符，可以将元组解压为列表

zipp=zip(a,b)
#result
[(1,4),(2,5),(3,6)]

zipp=zip(a,c)
#result
# 元素个数与最短的列表一致
[(1,4),(2,5),(3,6)]

zip(*zipp)
# 与 zip 相反，可理解为解压，返回二维矩阵式
[(1,2,3),(4,5,6)]

tf.tile()

函数定义：

def tile(input, multiples, name=None):

函数功能：在指定的维度上复制N遍），来创建出一个新的 tensor。

3个参数：
input：输入的tensor
multiples：在指定的维度上复制原tensor的次数
name：operation的名字

import tensorflow as tf

with tf.Session() as sess:
    a = tf.constant([[15, 16], [17, 18]])
    b = tf.tile(a, [1, 3])
    c = tf.tile(a, [3, 2])
    print('------------------------------------')
    print(sess.run(a))
    print('------------------------------------')
    print(sess.run(b))
    print('------------------------------------')
    print(sess.run(c))

[[15 16]
 [17 18]]
------------------------------------
[[15 16 15 16 15 16]
 [17 18 17 18 17 18]]
------------------------------------
[[15 16 15 16]
 [17 18 17 18]
 [15 16 15 16]
 [17 18 17 18]
 [15 16 15 16]
 [17 18 17 18]]

输入的 a 是一个 2x2 的矩阵，tf.tile(a, [1, 3]) 里的 [1, 3] 表示在第一个维度上把输入的tensor重复1遍，在第二个维度上把输入的tensor重复3遍。在本例中，第一个维度就是行，第二个维度就是列，因此 b 就变成了 2x6 的矩阵。
注意：tf.tile() 里的第2个参数，例如 [1, 3]，里面有两个元素，它必须与输入的 tensor 的维度一样（2维），如果输入的 tensor 是3维的，那么 tf.tile() 的第2个参数里也必须有3个元素，例如 [2, 3, 5]，否则会报类似于下面的错：

ValueError: Shape must be rank 3 but is rank 1 for 'Tile_1' (op: 'Tile') with input shapes

tf.truncated_normal与tf.random_normal的区别

作为tensorflow里的正态分布产生函数，这两个函数的输入参数几乎完全一致，

而其主要的区别在于，tf.truncated_normal的输出如字面意思是截断的，而截断的标准是2倍的stddev。

举例，当输入参数mean = 0 ， stddev =1时，

使用tf.truncated_normal的输出是不可能出现[-2,2]以外的点的，

而如果shape够大的话，tf.random_normal却会产生2.2或者2.4之类的输出。

python将nan, inf转为特定的数字

处理两个矩阵的点除，得到结果后，再作其他的计算，发现有些内置的函数不work；查看得到的数据，发现有很多nan和inf，导致python的基本函数运行不了，这是因为在除的过程中分母出现0的缘故。为了将结果能够被python其他函数处理，尤其numpy库，需要将nan，inf转为python所能识别的类型。这里将nan，inf替换0作为例子。

代码

import numpy as np
a = np.array([[np.nan, np.nan, 1, 2], [np.inf, np.inf, 3, 4], [1, 1, 1, 1], [2, 2, 2, 2]])
print a
where_are_nan = np.isnan(a)
where_are_inf = np.isinf(a)
a[where_are_nan] = 0
a[where_are_inf] = 0
print a
print np.mean(a)

结果

[[ nan  nan   1.   2.]
 [ inf  inf   3.   4.]
 [  1.   1.   1.   1.]
 [  2.   2.   2.   2.]]
[[ 0.  0.  1.  2.]
 [ 0.  0.  3.  4.]
 [ 1.  1.  1.  1.]
 [ 2.  2.  2.  2.]]
1.375

tf.contrib.keras.preprocessing.sequence.pad_sequences 将标量数据 转换成numpy ndarray

keras.preprocessing.sequence.pad_sequences(sequences, maxlen=None, dtype=’int32’, padding=’pre’, truncating=’pre’, value=0.)
函数说明：
将长为nb_samples的序列（标量序列）转化为形如(nb_samples,nb_timesteps)2D numpy array。如果提供了参数maxlen，nb_timesteps=maxlen，否则其值为最长序列的长度。其他短于该长度的序列都会在后部填充0以达到该长度。长于nb_timesteps的序列将会被截断，以使其匹配目标长度。padding和截断发生的位置分别取决于padding和truncating.
参数
sequences：浮点数或整数构成的两层嵌套列表

maxlen：None或整数，为序列的最大长度。大于此长度的序列将被截短，小于此长度的序列将在后部填0.

dtype：返回的numpy array的数据类型

padding：‘pre’或‘post’，确定当需要补0时，在序列的起始还是结尾补

truncating：‘pre’或‘post’，确定当需要截断序列时，从起始还是结尾截断

value：浮点数，此值将在填充时代替默认的填充值0

返回值
返回形如(nb_samples,nb_timesteps)的2D张量

import tensorflow as tf
import numpy as np

pad_sequence = tf.contrib.keras.preprocessing.sequence.pad_sequences

a=[[1,2,3],[4,5,6,7]]
b_len=np.array([len(_) for _ in a])
bs_packed = pad_sequence(a,maxlen=4,padding='pre',truncating='pre',value = 0)

print(bs_packed)

输出：
[[0 1 2 3]
[4 5 6 7]]

tf.data.Dataset.from_tensor_slices

tf.data.Dataset.from_tensor_slices
该函数是dataset核心函数之一，它的作用是把给定的元组、列表和张量等数据进行特征切片。切片的范围是从最外层维度开始的。如果有多个特征进行组合，那么一次切片是把每个组合的最外维度的数据切开，分成一组一组的。

假设我们现在有两组数据，分别是特征和标签，为了简化说明问题，我们假设每两个特征对应一个标签。之后把特征和标签组合成一个tuple，那么我们的想法是让每个标签都恰好对应2个特征，而且像直接切片，比如：[f11, f12] [t1]。f11表示第一个数据的第一个特征，f12表示第1个数据的第二个特征，t1表示第一个数据标签。那么tf.data.Dataset.from_tensor_slices就是做了这件事情：

import tensorflow as tf
import numpy as np

features, labels = (np.random.sample((6, 3)),  # 模拟6组数据，每组数据3个特征
                    np.random.sample((6, 1)))  # 模拟6组数据，每组数据对应一个标签，注意两者的维数必须匹配

print((features, labels))  #  输出下组合的数据
data = tf.data.Dataset.from_tensor_slices((features, labels))
print(data)  # 输出张量的信息

dataset中shuffle()、repeat()、batch()用法

import numpy as np
import tensorflow as tf
np.random.seed(0)
x = np.random.sample((11,2))
# make a dataset from a numpy array
print(x)

dataset = tf.data.Dataset.from_tensor_slices(x)
dataset = dataset.shuffle(2)  # 将数据打乱，数值越大，混乱程度越大
dataset = dataset.batch(4)  # 按照顺序取出4行数据，最后一次输出可能小于batch
dataset = dataset.repeat()  # 数据集重复了指定次数
# repeat()在batch操作输出完毕后再执行,若在之前，相当于先把整个数据集复制两次
#为了配合输出次数，一般默认repeat()空

# create the iterator
iter = dataset.make_one_shot_iterator()
el = iter.get_next()

with tf.Session() as sess:
    for i in range(6):
        value = sess.run(el)
        print(value)