张量的常用函数

默认已经导入tensorflow和numpy

1.计算

强制tensor转换为改数据类型

        tf.cast(张量名, dtype=数据类型)

计算张量维度上元素的最小值

        tf.reduce_min(张量名)

计算张量维度上元素的最大值

        tf.reduce_max(张量名)

a1 = tf.constant([1,2,3],dtype=tf.float64)
print(a1)
a2 = tf.cast(a1,dtype=tf.int64)
print(a2)

print(tf.reduce_min(a2))

print(tf.reduce_max(a2))

理解axis

在一个二维张量中axis=0表示对第一个维度进行操作，axis=1表示对第二个维度进行操作。

axis=0代表跨行，axis=1代表跨列，若不指定axis，所有元素均参与计算

比如，

        计算张量沿着指定维度的平均值

                tf.reduce_mean(张量名， axis=操作轴)

        计算张量沿着指定维度的和

                tf.reduce_sum(张量名，axis=操作轴)

b1 = tf.constant([[1,2,3],[2,3,4]])
print(b1)
b2 = tf.reduce_mean(b1, axis=0)
b3 = tf.reduce_mean(b1, axis=1)
b4 = tf.reduce_sum(b1)

with tf.Session() as sess:
    print("横向mean:")
    print(b2.eval())
    print("纵向mean:")
    print(b3.eval())
    print("sum:")
    print(b4.eval())

2. tf.Variable

w = tf.Variable(初始值) 

tr.Variable() 将变量标记为“可训练”，被标记的变量会在反向传播中记录梯度信息。神经网络训练中，常用该函数标记待训练参数。

w = tf.Variable(tf.random.normal([2,2],mean=0, stddev=1))

3. 常用的运算：

        四则：tf.add，tf.sbutract，tf.multiply，tf.divide

                tf.add(张量1，张量2)        tf.substract(张量1，张量2)        

                tf.multiply(张量1，张量2)  tf.divide(张量1，张量2)

        只有维度相同的张量才能做四则运算

a = tf.ones([1,3],dtype=tf.int32)
b = tf.fill([1,3],3)

with tf.Session() as sess:
    print("a:")
    print(a)
    print("b:")
    print(b)
    sum_ab = tf.add(a,b).eval()
    print(f"a+b的结果是{sum_ab}")
    sub_ab = tf.subtract(a,b).eval()
    mul_ab = tf.multiply(a,b).eval()
    div_ab = tf.divide(a,b).eval()
    print(f"a-b的结果是{sub_ab}")
    print(f"a×b的结果是{mul_ab}")
    print(f"a÷b的结果是{div_ab}")

        平方、次方与开方：tf.square，tf.pow，tf.sqrt

                tf.square(张量名)        tf.pow(张量名, n次方)        tf.sqrt(张量名)

c = tf.fill([1,2],3.)
with tf.Session() as sess:
    print("c:")
    print(c.eval())
    print(tf.square(c).eval())
    print(tf.pow(c,3).eval())
    print(tf.sqrt(c).eval())

        矩阵乘：tf.matmul

d = tf.ones([2,3])
e = tf.fill([3,2], 3.)
with tf.Session() as sess:
    print("d:")
    print(d.eval())
    print("e:")
    print(e.eval())
    print(tf.matmul(d,e).eval())

4.  tf.data.Dataset.from_tensor_slices

        切分传入张量的第一维度，生成输入特征/标签对，构建数据集 

data = tf.data.Dataset.from_tensor_slices((输入特征，标签))     // Numpy和Tensor格式均可读入。

feature = tf.constant([1,3,5,7])
label = tf.constant([1,9,25,49])
dataset = tf.data.Dataset.from_tensor_slices((feature,label))

5. tf.GradientTape

        with 结构记录计算过程，gradient求出张量的梯度

        with tf.GradientTape() as tape:

                若干计算过程

        grad = tape.gradient(函数，对谁求导)

with tf.GradientTape() as tape:
    w = tf.Variable(tf.constant(3.0))
    loss = tf.pow(w,2)
grad = tape.gradient(loss, w)
print(grad)

     

    如果报错了，在导入tensorflow包第二行加入tf.enable_eager_execution()

import tensorflow as tf
tf.enable_eager_execution()
import numpy as np

6. enumerate

        enumerate是python内建函数，它可遍历每个元素（如列表、元组或者字符串），组合为索引  元素，常在for循环中使用。

        enumerate(列表名)

seq = ["one", "two", "three"]
for i,element in enumerate(seq):
    print(i,element)

7. one-hot 

        one-hot编码：在分类问题中，常用one-hot编码做标签，标记类别：1表示是，0表示非。

        tf.one_hot()函数啊将待转换数据，转换为one-hot形式的数据输出。

tf.one_hot(待转换数据，depth=几分类)

classes = 3
label = tf.constant([1,0,2])
output = tf.one_hot(label,depth=classes)
print(output)

8. tf.nn.softmax

当n分类的n个输出时，通过softmax函数，便符合概率分布了。

y = tf.constant([1.01,2.01,-0.66])
y_pro = tf.nn.softmax(y)
print(y_pro)

 9. assign_sub

赋值操作，更新参数的值并返回。调用assign_sub前，先用tf.Variable定义变量w为可训练（自更新）。

10. w.assign_sub(w要自减的内容)。

w = tf.Variable(4)
w.assign_sub(1)
print(w)

即w = w-1，或者 w-=1

 11. tf.argmax

返回张量沿指定维度最大的值的索引

 tf.argmax(张量名，axis=操作轴)

test = np.array([[1,2,3],[2,3,4],[3,4,5],[5,6,7]])
print(test)
max_0 = tf.argmax(test,axis=0)
max_1 = tf.argmax(test,axis=1)
print(f"axis为0，max = {max_0}")
print(f"axis为1，max = {max_1}") 

 注意是最大值得索引。

tf.where

条件语句真返回A，条件语句假返回B

tf.where(条件语句，真返回A，假返回B)

a = tf.constant([1,2,3,1,4])
b = tf.constant([0,1,3,4,5])
c = tf.where(tf.greater(a,b), a,b)
print("c:",c)

 np.random.RandomState.rand

返回一个[0,1)之间的随机数

np.random.RandomState.rand(维度)

rrs = np.random.RandomState(seed=1)
a = rrs.rand()      # 返回一个标量
b = rrs.rand(2,3)   #返回一个矩阵

 np.vstack()

将两个数组按垂直方向叠加

np.vstack(数组1, 数组2)

a = np.array([1,2,3])
b = np.array([4,5,6])
c = np.vstack((a,b))

print("a:",a)
print("b:",b)
print("c:",c)

np.mgrid[ ]        .ravel( )        np.c_[ ]

np.mgrid[ ]

np.mgrid[ 起始值：结束值：步长，起始值：结束值：步长……]  左闭右开

x.ravel( )  将x变为以为数组，“把 . 前变量拉直”

np.c_[ ]  使返回不的间隔数值点配对

np.c_[ 数组1，数组2，数组3 ……]   像保持一个第一个数组不动，另一个按照相应维度叠加上去

x, y = np.mgrid[1:4:1, 3:5:0.5]
print("x:",x)
print("y:",y)
grid = np.c_[x.ravel(),y.ravel()]
print("grid:",grid)