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中的错误类不常用，可作为工具，使用时查询一下即可。不专门做笔记。
扫一扫
332
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
