TensorFlow2基础部分+命令解析+示例

该部分内容主要介绍了介绍了如何创建张量，对张量进行索引切片，维度变换和常见的数学运算等操作。

1、数据类型

标量、向量、矩阵。

import  os
os.environ['TF_CPP_MIN_LOG_LEVEL']='2'
import  tensorflow as tf
a = 1.2
aa = tf.constant(1.2)       # 创建标量
b = tf.constant([1.2,3.4,5])  # 通过List[]创建向量
c = tf.constant([[1.1,2],[3,4]])    # int32表示整数，float32表示浮点数。
print(type(a), type(aa), tf.is_tensor(aa),tf.is_tensor(b))
print(c)
print(b)

张量.numpy()可以返回 Numpy.array 类型的数据，方便导出数据到系统的其他模块：

import  os
os.environ['TF_CPP_MIN_LOG_LEVEL']='2'
import  tensorflow as tf
b = tf.constant([1.2,3.4,5])  # 创建向量
c = tf.constant([[1.1,2],[3,4]])    # int32表示整数，float32表示浮点数。
d = c.numpy()
print(b.numpy())
print(d)
print(d[:,0])   # 取d得第一列
print(b.shape,c.shape)  # b和c的数组大小

2、字符串类型

tf.strings模块中途中了很多工具函数，拼接 join()，长度 length()，切分 split()，小写lower()

import  os
os.environ['TF_CPP_MIN_LOG_LEVEL']='2'
import  tensorflow as tf
a = tf.constant('Hello, Deep LearninG.')    # 利用当引号创建字符串
b = tf.strings.lower(a)     # 将字符串全用小写表示
print(a,b)

3、布尔类型

import  os
os.environ['TF_CPP_MIN_LOG_LEVEL']='2'
import  tensorflow as tf
a = tf.constant(False) # 创建布尔张量
print(a == False)
b = tf.constant([True, False])
print(b)

4、数值精度

常用的精度类型有 tf.int16, tf.int32, tf.int64, tf.float16, tf.float32,tf.float64，其中 tf.float64 即为 tf.double。Bit 位越长，精度越高，同时占用的内存空间也就越大。（8个bit为一个字节byte）

import  os
os.environ['TF_CPP_MIN_LOG_LEVEL']='2'
import  tensorflow as tf
import numpy as np
a = tf.constant(123456789, dtype=tf.int16)
b = tf.constant(123456789, dtype=tf.int32)
c = tf.constant(np.pi, dtype=tf.float32)
d = tf.constant(np.pi, dtype=tf.float64)
print(a,b,c,d)
# 通过对象.dtype函数读取精度
print('before:',a.dtype)
if a.dtype != tf.float32:
    a = tf.cast(a,tf.float32) # 转换精度
print('after :',a.dtype)

4.1 # 利用tf.cast进行精度类型转换    4.2 # tf.tool函数完成数字与布尔值的转换，0对应False,非0值都对应1

import  os
os.environ['TF_CPP_MIN_LOG_LEVEL']='2'
import  tensorflow as tf
import numpy as np
a = tf.constant(np.pi, dtype=tf.float16)
# 利用tf.cast进行精度类型转换
b = tf.cast(a, tf.double)    # 与tf.float64等价
print(b.dtype)
# tf.tool函数完成数字与布尔值的转换，0对应False,非0值都对应1
a = tf.constant([-1.1, 0, 1, 2])
d = tf.cast(a,tf.bool)
print(d)

5、待优化张量

 利用tf.Variable()函数区分需要计算梯度信息的张量与不需要计算梯度信息的张量。

通过tf.Variable()函数由普通张量创建Variable，也可以直接创建。注：普通张量也可以通过 GradientTape.watch()方法临时加入跟踪梯度信息的列表。

import  os
os.environ['TF_CPP_MIN_LOG_LEVEL']='2'
import  tensorflow as tf
# 通过tf.Variable()函数由普通张量创建Variable
a = tf.constant([-1, 0, 1, 2])
aa = tf.Variable(a)
print(a)
print(aa)
print(aa.name)
print(aa.trainable)
# 直接创建Variable
b = tf.Variable([[1,2],[3,4]])
print(b.trainable)    # trainable表示True或False

6、创建张量

通过tf.constant（）或者tf.convert_to_tensor（）函数将Numpy Array或Python List数据转化为张量。

import  os
os.environ['TF_CPP_MIN_LOG_LEVEL']='2'
import  tensorflow as tf
import numpy as np
a = tf.convert_to_tensor([1,2.])    # 向量到张量
print(a)
b = a.numpy()       # 张量到数组
print(b)
c = tf.convert_to_tensor(np.array([[1,2.],[3,4]]))  # 矩阵到张量
print(c)

通过tf.zeros()和tf.ones()函数创建任意形状全0或全1的张量。

import  os
os.environ['TF_CPP_MIN_LOG_LEVEL']='2'
import  tensorflow as tf
# 创建为 0 和为 1 的标量张量
a = tf.zeros([])
b = tf.ones([])
print(a,b)
# 创建全 0 和全 1 的向量
c = tf.zeros([5])
d = tf.ones([5])
print(c,d)
# 创建全 0和全1 的矩阵
e = tf.zeros([5,5])
f = tf.ones([5,5])
print(e,f)

通过 tf.zeros_like, tf.ones_like 可以方便地新建与某个张量 shape 一致，内容全 0 或全 1的张量。 

import  os
os.environ['TF_CPP_MIN_LOG_LEVEL']='2'
import  tensorflow as tf
# 创建与张量 a 形状一样的全 0 张量.
a = tf.ones([2,3])
b = tf.zeros_like(a)
print(b)
# 创建与张量 a 形状一样的全 1 张量
c = tf.zeros([3,2])
d = tf.ones_like(a)
print(d)

 通过 tf.fill(shape, value)可以创建全为自定义数值 value 的张量。

import  os
os.environ['TF_CPP_MIN_LOG_LEVEL']='2'
import  tensorflow as tf
# 创建元素为-1的标量：
a = tf.fill([], -1)
print(a)
# 创建所有元素为-1 的向量：
b = tf.fill([5], -1)
print(b)
# 创建所有元素为 5 的矩阵：
c = tf.fill([3,4], 5)
print(c)

通过 tf.random.normal(shape, mean=0.0, stddev=1.0)可以创建形状为 shape，均值为mean，标准差为stddev的正太分布N(mean,stddev^2)。

import  os
os.environ['TF_CPP_MIN_LOG_LEVEL']='2'
import  tensorflow as tf
# 创建均值为0，标准为1的正太分布
a = tf.random.normal([3,3])		
print(a)
# 创建均值为 1，标准差为 2 的正太分布：
b = tf.random.normal([3,3], mean=1,stddev=2)
print(b)

通过 tf.random.uniform(shape, minval=0, maxval=None, dtype=tf.float32)可以创建采样自[minval,maxval]区间的均匀分布张量。

import  os
os.environ['TF_CPP_MIN_LOG_LEVEL']='2'
import  tensorflow as tf
# 创建采样自区间[0,1],shape为[2,2]的矩阵：
a = tf.random.uniform([3,3])
print(a)
b = tf.random.uniform([3,3],maxval=10)
print(b)
c = tf.random.uniform([3,3],maxval=100,dtype=tf.int32)
print(c)

 

通过tf.range(start,limit,delta=1)函数创建[start,limit),步长为delta的序列，不包含limit本身。

import  os
os.environ['TF_CPP_MIN_LOG_LEVEL']='2'
import  tensorflow as tf
# 创建 0~9，步长为 1 的整形序列
a = tf.range(10)
print(a)
# 创建 0~9，步长为 2 的整形序列
b = tf.range(10,delta=2)
print(b)
c = tf.range(1,10,delta=2)
print(c)

 7、张量的典型应用

输出标量：

import  os
os.environ['TF_CPP_MIN_LOG_LEVEL']='2'
import  tensorflow as tf
# 标量
out = tf.random.uniform([4,10]) #随机模拟网络输出
y = tf.constant([2,3,2,0]) # 随机构造样本真实标签
y = tf.one_hot(y, depth=10) # one-hot 编码
loss = tf.keras.losses.mse(y, out) # 计算每个样本的 MSE
loss = tf.reduce_mean(loss) # 平均 MSE
print(out,y,loss)

 输出向量：

import  os
os.environ['TF_CPP_MIN_LOG_LEVEL']='2'
import  tensorflow as tf
# z=wx,模拟获得激活函数的输入 z
z = tf.random.normal([4,2])
b = tf.zeros([2]) # 模拟偏置向量
z1 = z + b # 累加偏置
print(z,b,z1)

 

import  os
os.environ['TF_CPP_MIN_LOG_LEVEL']='2'
import  tensorflow as tf
from tensorflow.keras  import layers
fc = layers.Dense(3) # 创建一层 Wx+b，输出节点为 3
# 通过 build 函数创建 W,b 张量，输入节点为 4
fc.build(input_shape=(2,4))
fc.bias # 查看偏置
print(fc.bias)

输出矩阵：

 其中 X，W 张量均是矩阵。x@w+b 网络层称为线性层。两个样本，每个样本的特征长度为4，输出节点数为3。通过下述程序实现： 

import  os
os.environ['TF_CPP_MIN_LOG_LEVEL']='2'
import  tensorflow as tf
x = tf.random.normal([2,4])
w = tf.ones([4,3]) # 定义 W 张量
b = tf.zeros([3]) # 定义 b 张量
o = x@w+b # X@W+b 运算
print(x,w,b,o)

在 TensorFlow 中可以通过 Dense类直接实现，Dense 层也称为全连接层。我们通过 Dense 类创建输入 4 个节点，输出 3 个
节点的网络层，可以通过全连接层的 kernel 成员名查看其权值矩阵 W：

import  os
os.environ['TF_CPP_MIN_LOG_LEVEL']='2'
import  tensorflow as tf
from tensorflow.keras import layers
fc = layers.Dense(3) # 定义全连接层的输出节点为 3
fc.build(input_shape=(2,4)) # 定义全连接层的输入节点为 4
w = fc.kernel
print(w)

三维张量：

 

25000个句子，每个句子80个单词，每个单词采用长度为100的数字编码方式。 

import  os
os.environ['TF_CPP_MIN_LOG_LEVEL']='2'
import  tensorflow as tf
from tensorflow import keras
from tensorflow.keras import layers,datasets
# 自动加载 IMDB 电影评价数据集
(x_train,y_train),(x_test,y_test)=keras.datasets.imdb.load_data(num_words=10000)
# 将句子填充、截断为等长 80 个单词的句子
x_train = keras.preprocessing.sequence.pad_sequences(x_train,maxlen=80)
print(x_train.shape)
# 创建词向量 Embedding 层类
embedding=layers.Embedding(10000, 100)
# 将数字编码的单词转换为词向量
out = embedding(x_train)
print(out.shape)

4维张量：

import  os
os.environ['TF_CPP_MIN_LOG_LEVEL']='2'
import  tensorflow as tf
from tensorflow import keras
from tensorflow.keras import layers,datasets
# 创建 32x32 的彩色图片输入，个数为 4
x = tf.random.normal([4,32,32,3])
# 创建卷积神经网络
layer = layers.Conv2D(16,kernel_size=3)
out = layer(x) # 前向计算
print(out,out.shape) # 输出大小

 8、索引和切片

TensorFlow中，支持基本的[i][j]...标准索引方式，也支持通过逗号分隔索引号的索引方式。

import  os
os.environ['TF_CPP_MIN_LOG_LEVEL']='2'
import  tensorflow as tf
from tensorflow import keras
from tensorflow.keras import layers,datasets
# 创建 32x32 的彩色图片输入，个数为 4
x = tf.random.normal([4,32,32,3])
# 取第 1 张图片的数据：
x[0]
# 取第 1 张图片的第 2 行：
x[0][1]
# 取第 1 张图片，第 2 行，第 3 列的像素：
x[0][1][2]
# 取第 3 张图片，第 2 行，第 1 列的像素，B 通道(第 2 个通道)颜色强度值：
x[2][1][0][1]
# 采用[i,j,...,k]的方式索引
# 取第 2 张图片，第 10 行，第 3 列：
x[1,9,2]

通过start:end:step切片方式可以方便地提取一段数据，其中start为开始读取位置的索引，end为结束读取位置的索引（不包括end位），step为读取步长。

import  os
os.environ['TF_CPP_MIN_LOG_LEVEL']='2'
import  tensorflow as tf
from tensorflow import keras
from tensorflow.keras import layers,datasets
# 创建 32x32 的彩色图片输入，个数为 4
x = tf.random.normal([4,32,32,3])
# 读取2和3图片不包括3
x1 = x[1:3]
print(x1.shape)
# 读取第 1 张图片的所有行
x2 = x[1,::]
print(x2.shape)
x3 = x[:,0:28:2,0:28:2,:]
print(x3.shape)
# 逆序取到第 1 号元素，不包含第 1 号
a = tf.range(9)
a1 = x[8:0:-1]
b = x[::-1]
c = x[::-2]
print(a,a1,b)
# 读取每张图片的所有通道，其中行按着逆序隔行采样，列按着逆序隔行采样
x = tf.random.normal([4,32,32,3])
x[0,::-2,::-2]
# 读取G通道上的数据时，前面所有维度全部提取(RGB)
x[:,:,:,1]
# 读取第 1-2 张图片的 G/B 通道数据：
x[0:2,...,1:]
# 读取最后 2 张图片：
x[2:,...]
# 读取 R/G 通道数据：
x[...,:2]

9、维度变换

通过 tf.reshape(x, new_shape)，可以将张量的视图任意的合法改变：

import  os
os.environ['TF_CPP_MIN_LOG_LEVEL']='2'
import  tensorflow as tf
from tensorflow import keras
from tensorflow.keras import layers,datasets
a = tf.range(96)
b = tf.reshape(a,[2,4,4,3])
print(b.ndim,b.shape)		# nidm为维度
# 参数-1 表示当前轴上长度需要根据视图总元素不变的法则自动推导
c = tf.reshape(b,[2,-1])
print(c)
# 2张图片，4行12列
d = tf.reshape(c,[2,4,12])
print(d)
# 改变数据的视图为[2,16,3]	# 2组数据，每组1行16列
e = tf.reshape(d,[2,-1,3])
print(e)

增删维度：

通过 tf.expand_dims(x, axis)可在指定的 axis 轴前可以插入一个新的维度。

tf.squeeze(x, axis)可在指定的 axis 轴前可以删除一个维度。

import  os
os.environ['TF_CPP_MIN_LOG_LEVEL']='2'
import  tensorflow as tf
from tensorflow import keras
from tensorflow.keras import layers,datasets
# 创建28*28的举证
x = tf.random.uniform([3,3],maxval=10,dtype=tf.int32)
x1 = tf.expand_dims(x,axis=2)	# 在插入一个新的维度后，改变了数据的视图		
x2 = tf.expand_dims(x1,axis=0)
# 删除维度
x3 = tf.squeeze(x2, axis=0)
x4 = tf.squeeze(x1, axis=2)
# 如果不指定维度参数 axis，即 tf.squeeze(x)，那么他会默认删除所有长度为 1 的维度：
a = tf.random.uniform([1,28,28,1],maxval=10,dtype=tf.int32)
a = tf.squeeze(x) 
print(x,x1,x2,x3,x4,a)

交换维度：

import  os
os.environ['TF_CPP_MIN_LOG_LEVEL']='2'
import  tensorflow as tf
from tensorflow import keras
from tensorflow.keras import layers,datasets
x = tf.random.normal([2,5,5,3])
x1 = tf.transpose(x,perm=[0,3,1,2])
print(x.shape,x1.shape)

数据复制：tf.tile(x,multiples=[1,2])

import  os
os.environ['TF_CPP_MIN_LOG_LEVEL']='2'
import  tensorflow as tf
from tensorflow import keras
from tensorflow.keras import layers,datasets
b = tf.constant([1,2,3])
b1 = tf.expand_dims(b, axis=0)
b2 = tf.tile(b1, multiples=[3,2])	# 行复制3倍，列复制2倍
print(b,b1,b2)
#对于矩阵在列维度复制 1 份数据
x = tf.range(4)
x=tf.reshape(x,[2,2])
x = tf.tile(x,multiples=[1,2])

Broadcasting是一种轻量级张量复制的手段。

import  os
os.environ['TF_CPP_MIN_LOG_LEVEL']='2'
import  tensorflow as tf
from tensorflow import keras
from tensorflow.keras import layers,datasets
# 具有普适性
A = tf.random.normal([32,1])
B = tf.broadcast_to(A, [2,32,32,3])
# 报错,不具有普适性
#A = tf.random.normal([32,2])
#B = tf.broadcast_to(A, [2,32,32,4])
# 基本运算符的自动 Broadcasting 机制
a = tf.random.normal([2,32,32,1])
b = tf.random.normal([32,32])
print(a+b,a-b,a*b,a/b)

10、数学运算

import  os
os.environ['TF_CPP_MIN_LOG_LEVEL']='2'
import  tensorflow as tf
from tensorflow import keras
from tensorflow.keras import layers,datasets
a = tf.range(5)
b = tf.constant(2)
# 整除和余除
#print(a//b,a%b)
# 乘方
x = tf.range(4)
x1 = tf.pow(x,2)
x2 = x**2
#print(x,x1,x2)
# 常见的平方和平方根运算，可以使用 tf.square(x)和 tf.sqrt(x)实现
x = tf.range(5)
x = tf.cast(x, dtype=tf.float32)
x = tf.square(x)
tf.sqrt(x)
# 指数、对数
x = tf.constant([1.,2.,3.])
x1 = 2**x
x2 = tf.exp(2.)
x3 = tf.math.log(x2)
#print(x1,x2,x3)
x = tf.constant([1.,2.])
x = 10**x
x1 = tf.math.log(x)/tf.math.log(10.)
print(x1)

矩阵相乘：当张量 a,b 维度数大于 2时，TensorFlow 会选择 a,b 的最后两个维度进行矩阵相乘，前面所有的维度都视作 Batch 维
度。 tf.matmul(a, b)实现。

import  os
os.environ['TF_CPP_MIN_LOG_LEVEL']='2'
import  tensorflow as tf
from tensorflow import keras
from tensorflow.keras import layers,datasets
# 矩阵相乘
a = tf.random.normal([4,3,23,32])
b = tf.random.normal([4,3,32,2])
a@b
# 矩阵相乘函数支持自动 Broadcasting 机制
a = tf.random.normal([4,28,32])
b = tf.random.normal([32,16])
tf.matmul(a,b)