TensorFlow（1）张量及基本函数

参考视频及资料：https://www.bilibili.com/video/BV1B7411L7Qt?from=search&seid=202820015499098798

tensor

维数	阶	名字	例子
0	0	标量（）	s = 1 2 3
1	1	向量（）	v = [1,2,3]
2	2	矩阵（）	m = [[1,2,3],[4,5,6],[7,8,9]]
n	n	张量（）	t = [[[[[[[[ n个“[”

tensorflow的数据类型

tf.int,
tf.float ……
tf.int 32,
tf.float 32,
tf.float 64
tf.bool
tf.constant([True, False])
tf.string
tf.constant(“Hello, world!”)

创建一个张量（Tensor）

tf.constant(张量内容，dtype=数据类型(可选))

#创建一个张量（Tensor）
import tensorflow as tf

a = tf.constant([1, 5], dtype=tf.int64)
#创建1阶张量，里面两个元素分别为1,5
#指定数据类型为64位整型

print("a:", a)
print("a.dtype:", a.dtype)
#打印出a的数据类型
print("a.shape:", a.shape)
#打印出a的形状

a: tf.Tensor([1 5], shape=(2,), dtype=int64)
a.dtype: <dtype: 'int64'>
a.shape: (2,)

张量的形状看shape=（2，）中的逗号隔开了几个数字，上面示例中的逗号隔开了一个数字2，所以是1维张量，数字是2，说明这个张量里有两个元素，也就是上面的数值1和数值5

将numpy的数据类型转换为Tensor数据类型

tf. convert_to_tensor(数据名，dtype=数据类型(可选))

#将numpy的数据类型转换为Tensor数据类型
import tensorflow as tf
import numpy as np

a = np.arange(0, 5)
b = tf.convert_to_tensor(a, dtype=tf.int64)
#将numpy格式a变成了Tensor格式b

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

a: [0 1 2 3 4]
b: tf.Tensor([0 1 2 3 4], shape=(5,), dtype=int64)

创建全为0的张量

tf. zeros(维度)

创建全为1的张量

tf. ones(维度)

创建全为指定值的张量

tf. fill(维度，指定值)

#创建全为0，1，指定值的张量
import tensorflow as tf

a = tf.zeros([2, 3])
#创建一个2维张量，第一个维度有2个元素，第二个维度有3个元素，元素内容全是0

b = tf.ones(4)
#创建一个一维张量，里面有4个元素，内容全是1

c = tf.fill([2, 2], 9)
#创建一个两行两列的二维张量，第一个维度有2个元素，第二个维度有2个元素，元素都是9

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

a: tf.Tensor(
[[0. 0. 0.]
 [0. 0. 0.]], shape=(2, 3), dtype=float32)
b: tf.Tensor([1. 1. 1. 1.], shape=(4,), dtype=float32)
c: tf.Tensor(
[[9 9]
 [9 9]], shape=(2, 2), dtype=int32)

维度：
一维括号里直接写数字
二维用 [行，列]
多维用 [n,m,j,k……]，括号里写每个维度的元素个数，中间用逗号隔开

创建随机数组成的张量

生成正态分布的随机数，默认均值为0，标准差为1

tf. random.normal (维度，mean=均值，stddev=标准差)

生成截断式正态分布的随机数，

tf. random.truncated_normal (维度，mean=均值，stddev=标准差)

在tf.truncated_normal中如果随机生成数据的取值在（μ-2σ，μ+2σ）之外
则重新进行生成，保证了生成值在均值附近。μ：均值， σ：标准差

import tensorflow as tf

d = tf.random.normal([2, 2], mean=0.5, stddev=1)
#生成2行，2列的张量，里面的元素符合以0.5为均值，1为标准差的正态分布

print("d:", d)

e = tf.random.truncated_normal([2, 2], mean=0.5, stddev=1)
#生成2行，2列的张量，里面的元素符合以0.5为均值，1为标准差的截断式正态分布，生成的元素在{均值±（2*标准差）}之内
#数据更向均值0.5集中

print("e:", e)

d: tf.Tensor(
[[0.78079236 0.36991078]
 [0.5447546  0.85526705]], shape=(2, 2), dtype=float32)
e: tf.Tensor(
[[-1.0678291  -0.20061862]
 [ 0.1491285   0.40372872]], shape=(2, 2), dtype=float32)

生成均匀分布随机数 [ minval, maxval )

tf. random. uniform(维度，minval=最小值，maxval=最大值)

#生成平均分布的随机数
import tensorflow as tf

f = tf.random.uniform([2, 2], minval=0, maxval=1)
#生成两行两列张量，，其中的每个元素都符合在0~1之间的平均分布

print("f:", f)

f: tf.Tensor(
[[0.13252604 0.0960362 ]
 [0.35313892 0.33435488]], shape=(2, 2), dtype=float32)

实现强制tensor转换为该数据类型

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

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

tf.reduce_min (张量名)

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

tf.reduce_max (张量名)

#给定张量，转换张量的类型
#找出张量的最小值，最大值
import tensorflow as tf

x1 = tf.constant([1., 2., 3.], dtype=tf.float64)
#构建一个张量x1
print("x1:", x1)

x2 = tf.cast(x1, tf.int32)
#将x1变成32位整型
print("x2", x2)

print("minimum of x2：", tf.reduce_min(x2))
print("maxmum of x2:", tf.reduce_max(x2))
#打印x2的最小值，最大值

x1: tf.Tensor([1. 2. 3.], shape=(3,), dtype=float64)
x2 tf.Tensor([1 2 3], shape=(3,), dtype=int32)
minimum of x2： tf.Tensor(1, shape=(), dtype=int32)
maxmum of x2: tf.Tensor(3, shape=(), dtype=int32)

axis

在一个二维张量或数组中，可以通过调整 axis 等于0或1 控制执行维度。

axis=0代表跨行（经度，down)，
axis=1代表跨列（纬度，across)
如果不指定axis，则所有元素参与计算。

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

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

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

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

#axis
import tensorflow as tf

x = tf.constant([[1, 2, 3], [2, 2, 3]])

print("x:", x)
print("mean of x:", tf.reduce_mean(x)) 
# 不指定axis，求x中所有数的均值
print("sum of x:", tf.reduce_sum(x, axis=1))  
# 沿横向方向求每一行的和

x: tf.Tensor(
[[1 2 3]
 [2 2 3]], shape=(2, 3), dtype=int32)
mean of x: tf.Tensor(2, shape=(), dtype=int32)
sum of x: tf.Tensor([6 7], shape=(2,), dtype=int32)

tf.Variable ()将变量标记为“可训练”

被标记的变量会在反向传播中记录梯度信息。

神经网络训练中，常用该函数标记待训练参数。

tf.Variable(初始值)

#神经网络中初始化参数w的代码如下
w = tf.Variable(tf.random.normal([2, 2], mean=0, stddev=1))
#首先随机生成正态分布随机数，
#再给生成的随机数标记为可训练，

tensorflow中的数学计算函数

对应元素的四则运算（只有维度相同的张量才可以做四则运算）：加减乘除

tf.add，tf.subtract，tf.multiply，tf.divide

#实现两个张量的对应元素相加
tf.add (张量1，张量2)
#实现两个张量的对应元素相减
tf.subtract (张量1，张量2)
#实现两个张量的对应元素相乘
tf.multiply (张量1，张量2)
#实现两个张量的对应元素相除
tf.divide (张量1，张量2)

#张量之间的加减乘除
import tensorflow as tf

a = tf.ones([1, 3])
#创建一个1行3列的张量a，所有元素是1
b = tf.fill([1, 3], 3.)
#创建一个1行3列的张量2，所有元素是3

print("a:", a)
print("b:", b)
print("a+b:", tf.add(a, b))            #a和b对应元素相加
print("a-b:", tf.subtract(a, b))      #a和b对应元素相减
print("a*b:", tf.multiply(a, b))     #a和b对应元素相乘
print("b/a:", tf.divide(b, a))      #b中元素除以a

a: tf.Tensor([[1. 1. 1.]], shape=(1, 3), dtype=float32)
b: tf.Tensor([[3. 3. 3.]], shape=(1, 3), dtype=float32)
a+b: tf.Tensor([[4. 4. 4.]], shape=(1, 3), dtype=float32)
a-b: tf.Tensor([[-2. -2. -2.]], shape=(1, 3), dtype=float32)
a*b: tf.Tensor([[3. 3. 3.]], shape=(1, 3), dtype=float32)
b/a: tf.Tensor([[3. 3. 3.]], shape=(1, 3), dtype=float32)

平方，次方，开方

tf.square，tf.pow，tf.sqrt

#计算某个张量的平方
tf.square (张量名)
#计算某个张量的n次方
tf.pow (张量名，n次方数)
#计算某个张量的开方
tf.sqrt (张量名）

#张量次方，平方，开方操作
import tensorflow as tf

a = tf.fill([1, 2], 3.)    
#构建一个1行2列的二维张量，填充数值都是3
print("a:", a)
print("a的三次方:", tf.pow(a, 3))       #对a求三次方
print("a的平方:", tf.square(a))       #对a求平方
print("a的开方:", tf.sqrt(a))       #对a求开方

a: tf.Tensor([[3. 3.]], shape=(1, 2), dtype=float32)
a的三次方: tf.Tensor([[27. 27.]], shape=(1, 2), dtype=float32)
a的平方: tf.Tensor([[9. 9.]], shape=(1, 2), dtype=float32)
a的开方: tf.Tensor([[1.7320508 1.7320508]], shape=(1, 2), dtype=float32)

矩阵乘法：

tf.matmul

#实现两个矩阵的相乘
tf.matmul(矩阵1，矩阵2)

#矩阵相乘
import tensorflow as tf

a = tf.ones([3, 2])         #3行2列全1矩阵a
b = tf.fill([2, 3], 3.)     #2行3列全3矩阵b
print("a:", a)
print("b:", b)
print("a*b:", tf.matmul(a, b))
#结果是3行3列全6矩阵

a: tf.Tensor(
[[1. 1.]
 [1. 1.]
 [1. 1.]], shape=(3, 2), dtype=float32)
b: tf.Tensor(
[[3. 3. 3.]
 [3. 3. 3.]], shape=(2, 3), dtype=float32)
a*b: tf.Tensor(
[[6. 6. 6.]
 [6. 6. 6.]
 [6. 6. 6.]], shape=(3, 3), dtype=float32)

tf.data.Dataset.from_tensor_slices将输入特征和标签配对

神经网络是将输入特征和标签配对后再送入神经网络的，

tf.data.Dataset.from_tensor_slices可以实现将标签和特征进行配对，此函数对于numpy格式和tensor格式都适用

data = tf.data.Dataset.from_tensor_slices((输入特征, 标签))

#输入特征和标签配对
import tensorflow as tf

features = tf.constant([12, 23, 10, 17])
#收集的特征是12,23,10,17
labels = tf.constant([0, 1, 1, 0])
#每个特征对应的标签分别是0,1,1,0

dataset = tf.data.Dataset.from_tensor_slices((features, labels))
#使用tf.data.Dataset.from_tensor_slices()将特征和标签配上对

for element in dataset:     #分别打印每一个dataset
    print(element)

(<tf.Tensor: shape=(), dtype=int32, numpy=12>, <tf.Tensor: shape=(), dtype=int32, numpy=0>)
(<tf.Tensor: shape=(), dtype=int32, numpy=23>, <tf.Tensor: shape=(), dtype=int32, numpy=1>)
(<tf.Tensor: shape=(), dtype=int32, numpy=10>, <tf.Tensor: shape=(), dtype=int32, numpy=1>)
(<tf.Tensor: shape=(), dtype=int32, numpy=17>, <tf.Tensor: shape=(), dtype=int32, numpy=0>)

在with结构中使用tf.GradientTape实现某个函数对指定参数的求导运算

配合上面的tf.Variable()函数可以实现损失函数loss对参数w的求导运算

with tf.GradientTape( ) as tape:
	若干个计算过程
grad=tape.gradient(函数，对谁求导)

#求导运算
import tensorflow as tf

with tf.GradientTape() as tape:
    x = tf.Variable(tf.constant(3.0))    #将变量x设置为可训练的
    y = tf.pow(x, 2)                    #y=x^2
grad = tape.gradient(y, x)              #y对x求导，dy/dx=2*x,带入x=3，dy/dx=6.0
print(grad)

tf.Tensor(6.0, shape=(), dtype=float32)

enumerate（枚举）

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

enumerate(列表名)

#枚举
seq = ['one', 'two', 'three']   #新建列表赋值给seq
for i, element in enumerate(seq):
    #enumerate()括号里面是列表名；
    #i接收索引号，element接收元素
    print(i, element)

0 one
1 two
2 three

独热码

在实现分类问题时，常使用独热码来表示标签

1表示是对应元素
0表示不是对应元素

	（0）狗尾草鸢尾花	（1）杂色鸢尾花	（2）弗吉尼亚鸢尾花
标签为1对应的独热码	0	1	0
独热码表示的意义	0%的可能表示狗尾草鸢尾	100%的可能表示杂色鸢尾	0%的可能表示弗吉尼亚鸢尾

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

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

#独热码转换
import tensorflow as tf

classes = 3     #3分类
labels = tf.constant([1, 0, 2]) #待转换的数据
#输入的三个标签分别是1,0,2
#输入的元素值最小为0，最大为2
output = tf.one_hot(labels, depth=classes)
print("result of labels1:", output)
print("\n")

result of labels1: tf.Tensor(
[[0. 1. 0.]
 [1. 0. 0.]
 [0. 0. 1.]], shape=(3, 3), dtype=float32)

tf.nn.softmax，分类问题，将输出结果转化成符合概率分布的概率

tf.nn.softmax使输出符合概率分布，也就是将不同的输出转化成相对应的概率，输出的和为1

tf.nn.softmax(x) 使输出符合概率分布

使n分类的n个输出（y0 ，y1, …… yn-1）通过softmax( ) 函数，符合概率分布，也就是将每个输出值转化成0到1之间的概率值，，并且这些概率的和是1

#将神经网络前向传播结果转化成相对应的概率
import tensorflow as tf

y = tf.constant([1.01, 2.01, -0.66])    #将前向传播结果1.01,2.01，-0.66组成张量y
y_pro = tf.nn.softmax(y)                #将相应的y送入softmax函数，转化成相对应的概率

print("After softmax, y_pro is:", y_pro)           # y_pro 符合概率分布
print("The sum of y_pro:", tf.reduce_sum(y_pro))  # 通过softmax后，所有概率加起来和为1

After softmax, y_pro is: tf.Tensor([0.25598174 0.69583046 0.04818781], shape=(3,), dtype=float32)
The sum of y_pro: tf.Tensor(1.0, shape=(), dtype=float32)

assign_sub常用于参数的自更新，

调用assign_sub前，先用 tf.Variable 将等待更新的变量 w 为可训练（可自更新），才可以实现自更新

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

#自减，参数更新
import tensorflow as tf

x = tf.Variable(4)  #x先被定义为variable类型，初始值是4
x.assign_sub(1)     #对x做自减操作，即x=x-1，自减的内容写在括号里，括号里是1，则表示自减1
print("x:", x)  # 4-1=3

x: <tf.Variable 'Variable:0' shape=() dtype=int32, numpy=3>

tf.argmax返回张量沿指定维度最大值的索引，

注意返回的是索引号而不是值

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

import numpy as np
import tensorflow as tf

test = np.array([[1, 2, 3], [2, 3, 4], [5, 4, 3], [8, 7, 2]])     #2维张量test
print("test:\n", test)
print("每一列的最大值的索引号：", tf.argmax(test, axis=0))  # 返回纵向每一列最大值的索引号
print("每一行的最大值的索引号：", tf.argmax(test, axis=1))  # 返回横向每一行最大值的索引号

test:
 [[1 2 3]
 [2 3 4]
 [5 4 3]
 [8 7 2]]
每一列的最大值的索引号： tf.Tensor([3 3 1], shape=(3,), dtype=int64)
每一行的最大值的索引号： tf.Tensor([2 2 0 0], shape=(4,), dtype=int64)

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

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

import tensorflow as tf

a = tf.constant([1, 2, 3, 1, 1]) #定义一个1维张量a
b = tf.constant([0, 1, 3, 4, 5]) #定义一个1维张量b

c = tf.where(tf.greater(a, b), a, b)  # 若a>b，返回a对应位置的元素，否则返回b对应位置的元素
# a>b是否成立，成立则返回a中对应位置的元素，不成立则返回b中对应位置的元素
# 1>0成立，返回a中的1
# 2>1成立，返回a中的2
# 3>3不成立，返回b中的3
# 1>4不成立，返回b中的4
# 1>5不成立，返回b中的5
# 所以c应该为张量([1 2 3 4 5])

print("c：", c)

c： tf.Tensor([1 2 3 4 5], shape=(5,), dtype=int32)

np.random.RandomState.rand() 返回一个[0,1)之间的随机数

0是闭区间，1是开区间

np.random.RandomState.rand(维度)      #维度为空，返回标量

#随机数
import numpy as np

rdm = np.random.RandomState(seed=1)     #seed=常数,随机数种子相同则每次生成随机数相同
a = rdm.rand()          #维度为空，返回标量
b = rdm.rand(2, 3)      # 返回维度为2行3列随机数矩阵

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

a: 0.417022004702574
b: [[7.20324493e-01 1.14374817e-04 3.02332573e-01]
 [1.46755891e-01 9.23385948e-02 1.86260211e-01]]

np.vstack() 将两个数组按垂直方向叠加

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

#数组叠加
import numpy as np
a = np.array([1,2,3])
b = np.array([4,5,6])
c = np.vstack((a,b)) 
print("c:\n",c)

c:
 [[1 2 3]
 [4 5 6]]

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

这三个函数经常一起使用，可以生成网格坐标点

np.mgrid[ ] 返回若干组维度相同的等差数组

np.mgrid[ 起始值 : 结束值 : 步长 ，起始值 : 结束值 : 步长 , … ]      
#起始值和结束值是前闭后开区间

.ravel() 将多维数组变成一维数组

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

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

np.c_[ 数组1，数组2， … ]

import numpy as np
import tensorflow as tf

# 生成等间隔数值点
# x中包含1，不包含3，步长为1
# y中包含2，不包含4，步长为0.5
x,y = np.mgrid[1:3:1, 2:4:0.5]

# 先将x, y拉直，然后合并配对为二维张量，生成二维坐标点
grid = np.c_[x.ravel(), y.ravel()]

print("x:\n", x)
print("y:\n", y)

print("x.ravel():\n", x.ravel())
# x.ravel()将x拉直为1维数组
print("y.ravel():\n", y.ravel())
print('grid:\n', grid)

x:
 [[1. 1. 1. 1.]
 [2. 2. 2. 2.]]
y:
 [[2.  2.5 3.  3.5]
 [2.  2.5 3.  3.5]]
x.ravel():
 [1. 1. 1. 1. 2. 2. 2. 2.]
y.ravel():
 [2.  2.5 3.  3.5 2.  2.5 3.  3.5]
grid:
 [[1.  2. ]
 [1.  2.5]
 [1.  3. ]
 [1.  3.5]
 [2.  2. ]
 [2.  2.5]
 [2.  3. ]
 [2.  3.5]]