Tensorflow编程基础笔记之一——基础类型及操作函数

TensorFlow编程基础笔记之一——基础类型及操作函数

1.1 张量介绍

• tensor类型（与python对比）

tensor类型	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.int8	8位无符号整型
DT_STRING	tf.string	可变长度的字节数组，每一个张量元素都是一个字节数组
DT_BOOL	tf.bool	布尔型
DT_COMPLEX64	tf.complex64	由两个32位浮点数组成的复数：实数和虚数

• 张量就是多维数组（列表），用“阶”表示张量的维度
  0阶张量称作标量，表示一个单独的数；
  1阶张量称作向量，表示一个一维数组；
  2阶张量称作矩阵，表示一个二维数组，它可以有i行j列个元素，每个元素可以用行号和列号共同索引到；
  判断张量是几阶的，就通过张量右边的方括号数，0个是0阶，n个是n阶；

1.2 张量的相关操作包括类型转换、数值操作、形状变换和数据操作

import numpy as np
import tensorflow as tf

#类型转换函数，共6个
a=np.array(['1','2','3'])
print(a)
b=tf.string_to_number(a,out_type=tf.float32,name='ToString')
c=tf.to_double(a,name='ToDouble')
d=tf.to_float(a,name='ToFloat')
e=tf.to_int32(a,name='ToInt32')
f=tf.to_int64(a,name='ToInt64')
#将a转换为第二个参数指定的类型
g=tf.cast(a,tf.float64,name='zhidingleixing')
print(b,c,d,e,f,g,sep='\n')

['1' '2' '3']
Tensor("ToString:0", shape=(3,), dtype=float32)
Tensor("ToDouble:0", shape=(3,), dtype=float64)
Tensor("ToFloat:0", shape=(3,), dtype=float32)
Tensor("ToInt32:0", shape=(3,), dtype=int32)
Tensor("ToInt64:0", shape=(3,), dtype=int64)
Tensor("zhidingleixing:0", shape=(3,), dtype=float64)

#数值操作相关的函数，共有13个
tensor=tf.ones([2,3],tf.int32)  #按指定类型与形状生成值为1的张量
tensor=tf.zeros([2,3],tf.int32)  #按指定类型和形状生成值为0的张量
test=[[1,2,3],[4,5,6],[7,8,9]]
tensor=tf.ones_like(test)  #生成和输出张量一样形状和类型的1
tensor=tf.zeros_like(test)  #生成和输出张量一样形状和类型的0
tensor=tf.fill([2,5],3)    #为指定形状填值
tensor=tf.constant([[1.0,2.0]])  #生成常量
tensor=tf.random_normal([2,4],mean=0,stddev=1.0,dtype=tf.float32,seed=2,name="normal")  #生成正态分布随机数
#截断正态分布随机数，均值mean，标准差stddev，只保留[mean-2*stddev,mean+2*stddev]范围内的随机数
tensor=tf.truncated_normal([2,4],mean=0,stddev=1.0,dtype=tf.float32,seed=2,name="normal")
#均匀分布随机数，范围为[minval,maxval]
tensor=tf.random_uniform([2,4],minval=0,maxval=9,dtype=tf.int32,seed=2,name="uniform")

tf.set_random_seed(1)  #设置随机数种子
#将输入值value按照size尺寸随机剪辑
tensor=tf.random_crop([[1,2,3,4],[5,6,7,8],[10,11,12,13]],[2,2],name="crop")
#在[start,stop]范围内产生num个数的等差数列。注意,start和stop要用浮点数表示，否则会报错。
tensor=tf.linspace(start=1.0,stop=5,num=10,name=None)
#在[start,limit)范围内以进步值delta产生等差数列。注意，不包括limit在内的。
tensor=tf.range(start=1,limit=5,delta=1)
with tf.Session() as sess:
    print(sess.run(tensor))

[1 2 3 4]

#形状变换相关函数，共6个/1
#tf.shape(input,name=None) 返回一个张量，其值为输入参数input的shape。这个input可以是张量，也可是一个数组或list。
t=[1,2,3,4,5,6,7,8,9]
print(np.shape(t))
tshape=tf.shape(t)
tshape2=tf.shape(tshape)
with tf.Session() as sess:
    print(sess.run(tshape))
    print(sess.run(tshape2))  

(9,)
[9]
[1]

#形状变换相关函数，共6个/2
#tf.size(input,name=None) 返回一个张量，其内容为输入内容的元素数量
#tf.rank(input,name=None) 返回一个张量，其内容为输入数据input的rank。
#tf.reshape(input,shape,name=None) 将原有输入数据的shape按照指定形状进行变化，生成一个新的张量
t=[[[[1,1,1,1],[2,2,2,2]],[[3,3,3,3],[4,4,4,4]]]]
sizet=tf.size(t)
rankt=tf.rank(t)
tt1=tf.reshape(t,[1,16])
#如果shape有元素[-1],则表示在该维度下按照原有数据自动计算。
tt2=tf.reshape(t,[2,-1])
with tf.Session() as sess:
    print(sess.run(sizet))
    print(sess.run(rankt))
    print(sess.run(tt1))
    print(sess.run(tt2))

16
4
[[1 1 1 1 2 2 2 2 3 3 3 3 4 4 4 4]]
[[1 1 1 1 2 2 2 2]
 [3 3 3 3 4 4 4 4]]

#形状变换相关函数，共6个/5
#tf.expand_dims(input,dim,name=None) 插入维度1进入一个tensor中
t=[[2,3,3],[4,5,5]]
print(np.shape(t))
t1=tf.expand_dims(t,0)
t2=tf.expand_dims(t,1)
t3=tf.expand_dims(t,2)
#如果此处写成t4=tf.expand_dims(t,3),则会出错，因为只有两个维度
t4=tf.expand_dims(t,-1)

with tf.Session() as sess:
    print("在第一个位置增加一个维度",np.shape(t1))
    print(sess.run(t1))
    print("在第二个位置增加一个维度",np.shape(t2))
    print(sess.run(t2))
    print("在第三个位置增加一个维度",np.shape(t3))
    print(sess.run(t3))
    print("在最后一个位置增加一个维度",np.shape(t4))
    print(sess.run(t4))

(2, 3)
在第一个位置增加一个维度 (1, 2, 3)
[[[2 3 3]
  [4 5 5]]]
在第二个位置增加一个维度 (2, 1, 3)
[[[2 3 3]]

 [[4 5 5]]]
在第三个位置增加一个维度 (2, 3, 1)
[[[2]
  [3]
  [3]]

 [[4]
  [5]
  [5]]]
在最后一个位置增加一个维度 (2, 3, 1)
[[[2]
  [3]
  [3]]

 [[4]
  [5]
  [5]]]

#形状变换相关函数，共6个/6
#tf.squeeze(inpput,dim,name=None) 将dim指定的维度去掉(dim所指定的维度必须为1，如果不为1则会报错)
t=[[[[2],[1]]]]
print(np.shape(t))
t1=tf.squeeze(t,0)
t2=tf.squeeze(t,1)
t3=tf.squeeze(t,3)
#如果写成t4=tf.squeeze(t,2)会出错，因为2对应的维度为2，不为1
t4=tf.squeeze(t,-1)

with tf.Session() as sess:
    print("去掉第一个位置的维度",np.shape(t1))
    print(sess.run(t1))
    print("去掉第二个位置的维度",np.shape(t2))
    print(sess.run(t2))
    print("去掉第四个位置的维度",np.shape(t3))
    print(sess.run(t3))
    print("去掉第四个位置的维度",np.shape(t4))
    print(sess.run(t4))    

(1, 1, 2, 1)
去掉第一个位置的维度 (1, 2, 1)
[[[2]
  [1]]]
去掉第二个位置的维度 (1, 2, 1)
[[[2]
  [1]]]
去掉第四个位置的维度 (1, 1, 2)
[[[2 1]]]
去掉第四个位置的维度 (1, 1, 2)
[[[2 1]]]

#数据操作相关函数，共8个/1
#tf.slice(input,begin,size,name=None) 对输入数据input进行切片操作，begin与size可以为List类型。
#要求begin与size的值必须一一对应，并且begin中每个值都要大于等于0且小于等于size中对应的值。
t=[[[1,1,1],[2,2,2]],[[3,3,3],[4,4,4]],[[5,5,5],[6,6,6]]]
print(np.shape(t))
slice1=tf.slice(t,[1,0,0],[1,1,3])
slice2=tf.slice(t,[1,0,0],[1,2,3])
slice3=tf.slice(t,[1,0,0],[2,1,3])
with tf.Session() as sess:
    print(sess.run(slice1))
    print(sess.run(slice2))
    print(sess.run(slice3))

(3, 2, 3)
[[[3 3 3]]]
[[[3 3 3]
  [4 4 4]]]
[[[3 3 3]]

 [[5 5 5]]]

#数据操作相关函数，共8个/2
#tf.split(value,num_or_size_split,axis=0,num=None,name='split') 沿着某一维度将tensor分离为num_or_size_splits
t=tf.reshape(tf.range(start=1,limit=151,delta=1),[5,30])
#沿着第一列将t按[4,15,11]分成3个张量
split0,split1,split2=tf.split(t,[4,15,11],1)
with tf.Session() as sess:
    print(t)
    print(sess.run(t))
    print(np.shape(split0))
    print(sess.run(split0))
    print(np.shape(split1))
    print(sess.run(split1))
    print(np.shape(split2))
    print(sess.run(split2))

Tensor("Reshape_2:0", shape=(5, 30), dtype=int32)
[[  1   2   3   4   5   6   7   8   9  10  11  12  13  14  15  16  17  18
   19  20  21  22  23  24  25  26  27  28  29  30]
 [ 31  32  33  34  35  36  37  38  39  40  41  42  43  44  45  46  47  48
   49  50  51  52  53  54  55  56  57  58  59  60]
 [ 61  62  63  64  65  66  67  68  69  70  71  72  73  74  75  76  77  78
   79  80  81  82  83  84  85  86  87  88  89  90]
 [ 91  92  93  94  95  96  97  98  99 100 101 102 103 104 105 106 107 108
  109 110 111 112 113 114 115 116 117 118 119 120]
 [121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138
  139 140 141 142 143 144 145 146 147 148 149 150]]
(5, 4)
[[  1   2   3   4]
 [ 31  32  33  34]
 [ 61  62  63  64]
 [ 91  92  93  94]
 [121 122 123 124]]
(5, 15)
[[  5   6   7   8   9  10  11  12  13  14  15  16  17  18  19]
 [ 35  36  37  38  39  40  41  42  43  44  45  46  47  48  49]
 [ 65  66  67  68  69  70  71  72  73  74  75  76  77  78  79]
 [ 95  96  97  98  99 100 101 102 103 104 105 106 107 108 109]
 [125 126 127 128 129 130 131 132 133 134 135 136 137 138 139]]
(5, 11)
[[ 20  21  22  23  24  25  26  27  28  29  30]
 [ 50  51  52  53  54  55  56  57  58  59  60]
 [ 80  81  82  83  84  85  86  87  88  89  90]
 [110 111 112 113 114 115 116 117 118 119 120]
 [140 141 142 143 144 145 146 147 148 149 150]]

#数据操作相关函数，共8个/3
#tf.concat(concat_dim,values,name='concat')  沿着某一维度连接tensor
t1=[[1,2,3],[4,5,6]]
t2=[[7,8,9],[10,11,12]]
print("t1:",t1)
print("t2:",t2)


with tf.Session() as sess:
    print("按行连接：",sess.run(tf.concat([t1,t2],0)),sep='\n')
    print("按列连接：",sess.run(tf.concat([t1,t2],1)),sep='\n')
    

t1: [[1, 2, 3], [4, 5, 6]]
t2: [[7, 8, 9], [10, 11, 12]]
按行连接：
[[ 1  2  3]
 [ 4  5  6]
 [ 7  8  9]
 [10 11 12]]
按列连接：
[[ 1  2  3  7  8  9]
 [ 4  5  6 10 11 12]]

#数据操作相关函数，共8个/4
#tf.stack(input,axis=0)  将两个N维张量列表沿着axis轴组合成一个沿着axis轴组合成一个N+1维的张量
t1=[[1,2,3],[4,5,6]]
t2=[[10,20,30],[40,50,60]]

with tf.Session() as sess:
    print("按行叠加起来：",sess.run(tf.stack([t1,t2])),sep="\n")
    print("按列叠加起来：",sess.run(tf.stack([t1,t2],axis=1)),sep="\n")

按行叠加起来：
[[[ 1  2  3]
  [ 4  5  6]]

 [[10 20 30]
  [40 50 60]]]
按列叠加起来：
[[[ 1  2  3]
  [10 20 30]]

 [[ 4  5  6]
  [40 50 60]]]

**注意：**tf.concat()和tf.stack()的区别在于维度是否增加了

#数据操作相关函数，共8个/5
#unstack(value,num=None,axis=0,name='unstack')  将输入value按照指定的行或列进行拆分，并输出含有num个元素的列表(list)
#axis=0表示按行拆分，axis=1表示按列拆分,num为输出list的个数，必须与预计输出的个数相等，否则会报错。可忽略这个参数
t=[[1,2,3],[4,5,6]]
with tf.Session() as sess:
    print("默认按行拆分：",sess.run(tf.unstack(t)),sep="\n")
    print("按列拆分：",sess.run(tf.unstack(t,axis=1)),sep="\n")

默认按行拆分：
[array([1, 2, 3]), array([4, 5, 6])]
按列拆分：
[array([1, 4]), array([2, 5]), array([3, 6])]

#数据操作相关函数，共8个/6
#tf.gather(params,indices,validate_indices=None,name=None) 合并索引indices所指示params中的切片
y=tf.constant([0.,2.,-1.])
t=tf.gather(y,[2,0])
with tf.Session() as sess:
    print("提取指定索引数据之前：",sess.run(y))
    print("提取指定索引数据之后,位置[2,0]：",sess.run(t))

提取指定索引数据之前： [ 0.  2. -1.]
提取指定索引数据之后,位置[2,0]： [-1.  0.]

#数据操作相关函数，共8个/7
#tf.one_hot(indices,depth,on_value=None,off_value=None,axis=None,dtype=None,name=None)  生成符合onehot编码的张量。
indices=[0,2,-1,1]    #要生成的张量，相当于指定位置设置为on_value
depth=3               #在depth长度的数组中，哪个索引的值为onehot值
on_value=5.0          #为onehot值时，该值为多少
off_value=0.0         #非onehot值时，该值为多少
#axis为-1时生成的shape为[indices长度,depth],为0时shape为[depth,indices长度]
#还可以是1，是指在类似时间序列（三维度以上）情况下，以时间序列优先而非batch优先，即[depth,batch,indices长度]
#这里的indices长度可以当成样本中的feature特征维度
axis=-1
t=tf.one_hot(indices,depth,on_value,off_value,axis)
with tf.Session() as sess:
    print(sess.run(t))

[[ 5.  0.  0.]
 [ 0.  0.  5.]
 [ 0.  0.  0.]
 [ 0.  5.  0.]]

#数据操作相关函数，共8个/8
#tf.count_nonzero(input_tensor,axis=None,keep_dims=False,dtype=dtype.int64,name=None,reduction_indices=None)  统计非0个数
t=tf.random_normal([4,4],dtype=tf.float32)
with tf.Session() as sess:
    print(sess.run(t))
    print("矩阵中的非0个数：",sess.run(tf.count_nonzero(t,1)))

[[-0.17469783  0.51620245  0.24235971 -0.58633131]
 [ 0.76381689  0.09761845 -0.80310112 -1.80997384]
 [ 0.81021774  0.5561316  -1.68870258  1.55662048]
 [ 2.5749476  -0.21812376  1.47960925  0.00541722]]
矩阵中的非0个数： [4 4 4 4]

1.3 算术运算函数

x=tf.Variable(20)
y=tf.Variable(2)
a=[0.9,2.5,2.3,1.5,-4.5]
b=[[2,2],[3,3]]
c=[[8,16],[2,3]]

d=tf.constant(2)
e=tf.constant(5)
def f1():return tf.multiply(d,17)
def f2():return tf.add(e,23)

init=tf.global_variables_initializer()
with tf.Session() as sess:
    sess.run(init)   #如果存在变量，而没有这个初始化的操作就会报错
    print("x=",sess.run(x),";y=",sess.run(y))
    sess.run(tf.assign(x,y))   #这个操作是：赋值操作。将y的值赋值给x变量
    print("令x=y后，x=",sess.run(x) )
    sess.run(tf.assign(x,20))
    print("x+y=",sess.run(tf.add(x,y)))   #求和
    print("x-y=",sess.run(tf.subtract(x,y)))  #减法
    print("x × y=",sess.run(tf.multiply(x,y)))  #乘法
    print("x ÷ y=",sess.run(tf.divide(x,y)))  #除法
    print("x % y=",sess.run(tf.mod(x,y)))  #取模
    print("abs(y-x)=",sess.run(tf.abs(tf.subtract(y,x))))  #求绝对值
    print("x取负=",sess.run(tf.negative(x)))  #求负（y=-x）
    print("返回输入x的符号=",sess.run(tf.sign(x)))  #x小于0返回-1，x=0返回0，x>0返回1
    print("x^2=",sess.run(tf.square(x)))  #求x的平方
    print("舍入最接近的整数之前，a=",a)  
    print("四舍五入的整数之后，a=",sess.run(tf.round(a)))
    print("使用tf.int32类型强制转换，实现小数截断，a=",sess.run(tf.to_int32(a)))
    print("b=",b)
    print("c=",c)
    print("幂次方计算，b^c=：",sess.run(tf.pow(b,c)))
    print("计算e的次方，e^4=",sess.run(tf.exp(4.0)))   #e的幂必须为float类型，不能是int型
    print("对数计算，计算自然对数,Ine^4=",sess.run(tf.log(tf.exp(4.0))))
    print("返回b,c中的最大值，max(b,c)=",sess.run(tf.maximum(b,c)))
    print("返回b,c中的最小值，min(b,c)=",sess.run(tf.minimum(b,c)))
    print("三角函数：sin,cos,tan,atan=",sess.run([tf.sin(1.0),tf.cos(1.0),tf.tan(1.0),tf.atan(1.0)]))
    print("满足条件就执行fn1，否则执行fn2,result=",sess.run(tf.cond(tf.less(d,e),f1,f2)))
    
    
    
    

x= 20 ;y= 2
令x=y后，x= 2
x+y= 22
x-y= 18
x × y= 40
x ÷ y= 10.0
x % y= 0
abs(y-x)= 18
x取负= -20
返回输入x的符号= 1
x^2= 400
舍入最接近的整数之前，a= [0.9, 2.5, 2.3, 1.5, -4.5]
四舍五入的整数之后，a= [ 1.  2.  2.  2. -4.]
使用tf.int32类型强制转换，实现小数截断，a= [ 0  2  2  1 -4]
b= [[2, 2], [3, 3]]
c= [[8, 16], [2, 3]]
幂次方计算，b^c=： [[  256 65536]
 [    9    27]]
计算e的次方，e^4= 54.5981
对数计算，计算自然对数,Ine^4= 4.0
返回b,c中的最大值，max(b,c)= [[ 8 16]
 [ 3  3]]
返回b,c中的最小值，min(b,c)= [[2 2]
 [2 3]]
三角函数：sin,cos,tan,atan= [0.84147096, 0.54030228, 1.5574077, 0.78539819]
满足条件就执行fn1，否则执行fn2,result= 34

1.4 矩阵相关的运算

diagonal=[1,2,3,4]
t=[[1,2,3,4],[4,5,6,7]]
t2=[[[[0,1,2,3],[4,5,6,7],[8,9,10,11]],[[12,13,14,15],[16,17,18,19],[20,21,22,23]]]]
dim=[3]  #dim为t2中的索引，3就代表shape中的最后一个值4.同理，使用-1也可以
with tf.Session() as sess:
    print("对角值：diag=",diagonal)
    print("返回一个给定对角值的对角tensor=",sess.run(tf.diag(diagonal)),sep="\n")
    print("返回对角值,diag()的逆操作：",sess.run(tf.diag_part(sess.run(tf.diag(diagonal)))))
    print("求一个二维Tensor足迹，即对角值之和：",sess.run(tf.trace(sess.run(tf.diag(diagonal)))))
    #tf.transpose()让输入按照参数perm指定的维度顺序进行转置操作。如果不指定perm，默认是一个全转置
    print("矩阵没有转置之前，t=",t)
    print("矩阵转置之后，t.T=",sess.run(tf.transpose(t)),sep="\n") #tf.tranpose(t)等价于tr.transpose(1,[1,0])
    #实际上这里的转置reverse(),就是针对各维度的全转置
    print("对一个4阶数组进行转置，t2,t2.shape=",t2,np.shape(t2),sep="\n")
    print("对一个4阶数组的最后一维转置之后，T,T.shape=",sess.run(tf.reverse(t2,dim)),np.shape(sess.run(tf.reverse(t2,dim))),sep="\n")
    print("对一个数组同时按照多个轴反转，T,T.shape=",sess.run(tf.reverse(t2,[1,2])),np.shape(sess.run(tf.reverse(t2,[1,2]))),sep="\n")
    #所谓的矩阵相乘，实际上就是二维以上数组之间的运算了，因此要对相关数组进行升维或降维
    print("矩阵相乘，diagonal * t.T=",sess.run(tf.matmul(tf.expand_dims(diagonal,0),tf.transpose(t))))

对角值：diag= [1, 2, 3, 4]
返回一个给定对角值的对角tensor=
[[1 0 0 0]
 [0 2 0 0]
 [0 0 3 0]
 [0 0 0 4]]
返回对角值,diag()的逆操作： [1 2 3 4]
求一个二维Tensor足迹，即对角值之和： 10
矩阵没有转置之前，t= [[1, 2, 3, 4], [4, 5, 6, 7]]
矩阵转置之后，t.T=
[[1 4]
 [2 5]
 [3 6]
 [4 7]]
对一个4阶数组进行转置，t2,t2.shape=
[[[[0, 1, 2, 3], [4, 5, 6, 7], [8, 9, 10, 11]], [[12, 13, 14, 15], [16, 17, 18, 19], [20, 21, 22, 23]]]]
(1, 2, 3, 4)
对一个4阶数组的最后一维转置之后，T,T.shape=
[[[[ 3  2  1  0]
   [ 7  6  5  4]
   [11 10  9  8]]

  [[15 14 13 12]
   [19 18 17 16]
   [23 22 21 20]]]]
(1, 2, 3, 4)
对一个数组同时按照多个轴反转，T,T.shape=
[[[[20 21 22 23]
   [16 17 18 19]
   [12 13 14 15]]

  [[ 8  9 10 11]
   [ 4  5  6  7]
   [ 0  1  2  3]]]]
(1, 2, 3, 4)
矩阵相乘，diagonal * t.T= [[30 60]]

1.5 复数操作函数

由于与本身的业务关系不是很大，因此暂不记入笔记

1.6 规约计算

• 规约计算的操作都会有降维的功能，在所有reduce_xxx系列操作函数中，都是以xxx的手段降维，每个函数都有axis这个参数，即沿某个方向，使用xxx方法对输入的Tensor进行降维。
• axis的默认值是None，即把input_tensor降到0维，即一个数。
• 对于二维input_tensor而言：axis=0，则按列计算；axis=1,则按行计算。

x=[[1,1,1],[1,1,1]]
a = tf.constant([[1,2,3], [4,5,6]])
b=[[True,True],[False,False]]
with tf.Session() as sess:
    #函数中的input_tensor是按照axis中已经给定的维度来减少的；除非 keep_dims 是true，否则张量的秩将在axis的每个条目中减少1；
    #如果keep_dims为true，则减小的维度将保留为长度1。
    print("x=",x)
    print("将input_tensor降到0维，tf.reduce_sum(x)=",sess.run(tf.reduce_sum(x)))
    print("将input_tensor按行降维，计算相同列的值，sess.run(tf.reduce_sum(x,0))=",sess.run(tf.reduce_sum(x,0)))
    print("将input_tensor按列降维，计算相同行的值，sess.run(tf.reduce_sum(x,1))=",sess.run(tf.reduce_sum(x,1)))
    print("按列降维，保持原维度，sess.run(tf.reduce_sum(x,1,keep_dims=True))=",sess.run(tf.reduce_sum(x,1,keep_dims=True)))
    print("搞不懂这个为什么得到的是6，难道是链式操作，先沿0规约，之后沿1规约",sess.run(tf.reduce_sum(x,[0,1])))  
    print("连乘原始数组a：",sess.run(a),sep="\n")
    print("行列连乘：",sess.run(tf.reduce_prod(a)))
    print("按行连乘：",sess.run(tf.reduce_prod(a, axis=0)))
    print("按列连乘：",sess.run(tf.reduce_prod(a, axis=1)))
    print("按行连乘,保持维度：",sess.run(tf.reduce_prod(a, axis=0,keep_dims=True)))
    print("按列连乘,保持维度：",sess.run(tf.reduce_prod(a, axis=1,keep_dims=True)))
    print("求tensor a中的最小值：",sess.run(tf.reduce_min(a)),sess.run(tf.reduce_min(a,axis=0)),sess.run(tf.reduce_min(a,axis=1)))
    print("求tensor a中的最大值：",sess.run(tf.reduce_max(a)),sess.run(tf.reduce_max(a,axis=0)),sess.run(tf.reduce_max(a,axis=1)))
    print("求tensor a中的平均值：",sess.run(tf.reduce_mean(a)),sess.run(tf.reduce_mean(a,axis=0)),sess.run(tf.reduce_mean(a,axis=1)))
    print("对tensor中的各个元素求逻辑与之前：b=",b)
    print("对tensor中的各个元素求逻辑与之后：b=",sess.run(tf.reduce_all(b)),sess.run(tf.reduce_all(b,0)),sess.run(tf.reduce_all(b,1)))
    

x= [[1, 1, 1], [1, 1, 1]]
将input_tensor降到0维，tf.reduce_sum(x)= 6
将input_tensor按行降维，计算相同列的值，sess.run(tf.reduce_sum(x,0))= [2 2 2]
将input_tensor按列降维，计算相同行的值，sess.run(tf.reduce_sum(x,1))= [3 3]
按列降维，保持原维度，sess.run(tf.reduce_sum(x,1,keep_dims=True))= [[3]
 [3]]
搞不懂这个为什么得到的是6，难道是链式操作，先沿0规约，之后沿1规约 6
连乘原始数组a：
[[1 2 3]
 [4 5 6]]
行列连乘： 720
按行连乘： [ 4 10 18]
按列连乘： [  6 120]
按行连乘,保持维度： [[ 4 10 18]]
按列连乘,保持维度： [[  6]
 [120]]
求tensor a中的最小值： 1 [1 2 3] [1 4]
求tensor a中的最大值： 6 [4 5 6] [3 6]
求tensor a中的平均值： 3 [2 3 4] [2 5]
对tensor中的各个元素求逻辑与之前：b= [[True, True], [False, False]]
对tensor中的各个元素求逻辑与之后：b= False [False False] [ True False]

1.7 分割

分割操作是TensorFlow不常用的操作，在复杂的网络模型里偶尔才会用到。由于与当前的业务关联不大，因此暂不学习。

1.8 序列比较与索引提取

对于序列和数组的操作，是比较常用的方法

x = tf.constant([[3, 2, 1], [2, 1, 3]])
a= [1, 2, 3, 4, 5, 6,0]
b= [2, 3, 5]
cond=[True,False,False,True]
c=[1,2,3,4]
d=[5,6,7,8]
e=[1,1,2,4,4,4,7,8,8,]
with tf.Session() as sess:
    print("当前操作的数组x=",sess.run(x),sep="\n")
    print("返回input最小值的索引index:",sess.run(tf.argmin(x)),sess.run(tf.argmin(x,0)),sess.run(tf.argmin(x,1)))
    print("返回input最大值的索引index:",sess.run(tf.argmax(x)),sess.run(tf.argmax(x,0)),sess.run(tf.argmax(x,1)))
    print("当前操作的数组是a,b=",a,b)
    print("返回数组a和数组b中不同值的索引,返回Tensor对象的元组（out，idx）：",sess.run(tf.setdiff1d(a,b)))
    print("当前操作的条件数组和其他数组cond,c,d=",cond,c,d)
    #如果x和y都为None，则该操作将返回condition中true元素的坐标。坐标以二维张量返回，
    #其中第一维（行）表示真实元素的数量，第二维（列）表示真实元素的坐标。
    #请记住，输出张量的形状可以根据输入中的真实值的多少而变化。索引以行优先顺序输出。    
    print("根据指定条件，返回对应的值或坐标：",sess.run(tf.where(cond)),sess.run(tf.where(cond,c,d)),sep="\n")
    print("当前操作的数组e=",e)
    print("返回一个元组，包括唯一化的数据列表和对应的index：",sess.run(tf.unique(e)))
    print("将数组a中元素的值当作索引,其值当索引，即张量的逆置换，返回新的张量：",a,sess.run(tf.invert_permutation(a)))
    print("将数组a沿着第一维进行随机重新排列：",a,sess.run(tf.random_shuffle(a)))

当前操作的数组x=
[[3 2 1]
 [2 1 3]]
返回input最小值的索引index: [1 1 0] [1 1 0] [2 1]
返回input最大值的索引index: [0 0 1] [0 0 1] [0 2]
当前操作的数组是a,b= [1, 2, 3, 4, 5, 6, 0] [2, 3, 5]
返回数组a和数组b中不同值的索引,返回Tensor对象的元组（out，idx）： ListDiff(out=array([1, 4, 6, 0]), idx=array([0, 3, 5, 6]))
当前操作的条件数组和其他数组cond,c,d= [True, False, False, True] [1, 2, 3, 4] [5, 6, 7, 8]
根据指定条件，返回对应的值或坐标：
[[0]
 [3]]
[1 6 7 4]
当前操作的数组e= [1, 1, 2, 4, 4, 4, 7, 8, 8]
返回一个元组，包括唯一化的数据列表和对应的index： Unique(y=array([1, 2, 4, 7, 8]), idx=array([0, 0, 1, 2, 2, 2, 3, 4, 4]))
将数组a中元素的值当作索引,其值当索引，即张量的逆置换，返回新的张量： [1, 2, 3, 4, 5, 6, 0] [6 0 1 2 3 4 5]
将数组a沿着第一维进行随机重新排列： [1, 2, 3, 4, 5, 6, 0] [2 0 4 1 5 3 6]

1.9 错误类

TensorFlow中的错误类不常用，可作为工具，使用时查询一下即可。不专门做笔记。