tensorflow常用基础变换

tf.slice

函数原型 tf.slice(inputs,begin,size,name=’’)
用途：从inputs中抽取部分内容

inputs：可以是list,array,tensor
begin：n维列表，begin[i] 表示从inputs中第i维抽取数据时，相对0的起始偏移量，也就是从第i维的begin[i]开始抽取数据
size：n维列表，size[i]表示要抽取的第i维元素的数目
有几个关系式如下:
（1） i in [0,n]
（2）tf.shape(inputs)[0]=len(begin)=len(size)
（3）begin[i]>=0 抽取第i维元素的起始位置要大于等于0
（4）begin[i]+size[i]<=tf.shape(inputs)[i]

代码：

import tensorflow as tf
import numpy as np

x = [[1, 2, 3], [4, 5, 6]]
y = np.arange(24).reshape([2, 3, 4])
z = tf.constant([[[1, 2, 3], [4, 5, 6]], [[7, 8, 9], [10, 11, 12]], [[13, 14, 15], [16, 17, 18]]])

sess = tf.Session()
begin_x = [1, 0]  # 第一个1，决定了从x的第二行[4,5,6]开始，第二个0，决定了从[4,5,6] 中的4开始抽取
size_x = [1, 2]  # 第一个1决定了，从第二行以起始位置抽取1行，也就是只抽取[4,5,6] 这一行，在这一行中从4开始抽取2个元素

out = tf.slice(x, begin=begin_x, size=size_x)
print (sess.run(out) ) # 结果:[[4 5]]

begin_y = [1, 0, 0]
size_y = [1, 2, 3]
out = tf.slice(y, begin_y, size_y)
print(sess.run(out)  )# 结果:[[[12 13 14] [16 17 18]]]

begin_z = [0, 1, 1]
size_z = [-1, 1, 2]
out = tf.slice(z, begin_z, size_z)
print(sess.run(out))  # size[i]=-1 表示第i维从begin[i]剩余的元素都要被抽取，结果：[[[ 5  6]] [[11 12]] [[17 18]]]

tf.transpose

主要注意多维的时候perm的用法，其实很简单，就是正常perm顺序是[0,1,2]，如果原来的shape是2x3x4的，对应的新perm顺序是多少，就把乘数的位置换到多少，也就是perm变成[1,0,2]那么shape就是3x2x4

import tensorflow as tf
 
#x = tf.constant([[1, 2 ,3],[4, 5, 6]])
x = [[[1,2,3,4],[5,6,7,8],[9,10,11,12]],[[21,22,23,24],[25,26,27,28],[29,30,31,32]]]
#a=tf.constant(x)
a=tf.transpose(x, [0, 1, 2])
b=tf.transpose(x, [0, 2, 1])
c=tf.transpose(x, [1, 0, 2])
d=tf.transpose(x, [1, 2, 0])
e=tf.transpose(x, [2, 1, 0])
f=tf.transpose(x, [2, 0, 1])

输出：

output:
--------------- a: 2 x 3*4
[[[ 1  2  3  4]
  [ 5  6  7  8]
  [ 9 10 11 12]]
 
 [[21 22 23 24]
  [25 26 27 28]
  [29 30 31 32]]]
--------------- b: 2 x 4*3
[[[ 1  5  9]
  [ 2  6 10]
  [ 3  7 11]
  [ 4  8 12]]
 
 [[21 25 29]
  [22 26 30]
  [23 27 31]
  [24 28 32]]]
--------------- c: 3 x 2*4
[[[ 1  2  3  4]
  [21 22 23 24]]
 
 [[ 5  6  7  8]
  [25 26 27 28]]
 
 [[ 9 10 11 12]
  [29 30 31 32]]]
--------------- d: 3 x 4*2
[[[ 1 21]
  [ 2 22]
  [ 3 23]
  [ 4 24]]
 
 [[ 5 25]
  [ 6 26]
  [ 7 27]
  [ 8 28]]
 
 [[ 9 29]
  [10 30]
  [11 31]
  [12 32]]]
--------------- e: 4 x 3*2
[[[ 1 21]
  [ 5 25]
  [ 9 29]]
 
 [[ 2 22]
  [ 6 26]
  [10 30]]
 
 [[ 3 23]
  [ 7 27]
  [11 31]]
 
 [[ 4 24]
  [ 8 28]
  [12 32]]]
---------------f: 4 x 2*3
[[[ 1  5  9]
  [21 25 29]]
 
 [[ 2  6 10]
  [22 26 30]]
 
 [[ 3  7 11]
  [23 27 31]]
 
 [[ 4  8 12]
  [24 28 32]]]
---------------

tf.nn.conv1d

conv1d的参数含义：(以NHWC格式为例，即，通道维在最后)

value：在注释中，value的格式为：[batch, in_width, in_channels]，batch为样本维，表示多少个样本，in_width为宽度维，表示样本的宽度，in_channels维通道维，表示样本有多少个通道。
filters：在注释中，filters的格式为：[filter_width, in_channels, out_channels]。按照value的第二种看法，filter_width可以看作每次与value进行卷积的行数，in_channels表示value一共有多少列（与value中的in_channels相对应）。out_channels表示输出通道，可以理解为一共有多少个卷积核，即卷积核的数目。
stride：一个整数，表示步长，每次（向下）移动的距离
padding：同conv2d，value是否需要在下方填补0。 Valid: 用过滤器在输入的矩阵中按步长移动时候，会把最后的不足部分的列和行抛弃；Same: 先在输入矩阵上下各加个值为0的行，在左右各加个个值为0的列，也就是用0把原先的矩阵包裹一层，然后在移动的时候如果输入矩阵的列或者行长度不够，就用0来补齐
name：名称。

测试代码：

import tensorflow as tf
import numpy as np

# 定义一个矩阵a，表示需要被卷积的矩阵。
a = np.array(np.arange(1, 1 + 20).reshape([1, 10, 2]), dtype=np.float32)
print(a, a.shape)
# 卷积核，此处卷积核的数目为1
kernel = np.array(np.arange(1, 1 + 4), dtype=np.float32).reshape([2, 2, 1])
print(kernel, kernel.shape)
# 进行conv1d卷积
conv1d = tf.nn.conv1d(a, kernel, 1, 'VALID')

with tf.Session() as sess:
    # 初始化
    tf.global_variables_initializer().run()
    # 输出卷积值
    out = sess.run(conv1d)
    print(out, out.shape)

输出：

a: shape (1, 10, 2)
a:
[[[ 1.  2.]
  [ 3.  4.]
  [ 5.  6.]
  [ 7.  8.]
  [ 9. 10.]
  [11. 12.]
  [13. 14.]
  [15. 16.]
  [17. 18.]
  [19. 20.]]]
  
filter: shape (2, 2, 1)
filter:
[[[1.]
  [2.]]

 [[3.]
  [4.]]]


output: shape(1, 9, 1)
output:
[[[ 30.]
  [ 50.]
  [ 70.]
  [ 90.]
  [110.]
  [130.]
  [150.]
  [170.]
  [190.]]]