tensorflow2.0 函数举例详解

import tensorflow as tf
from  tensorflow.keras import datasets, layers, optimizers, Sequential, metrics
import numpy as np

1、tf.data.Dataset.from_tensor_slices:它的作用是切分传入Tensor的第一个维度，生成相应的dataset。
将输入的张量的第一个维度看做样本的个数，沿其第一个维度将tensor切片，得到的每个切片是一个样本数据。实现了输入张量的自动切片

a = np.random.randint(0,10,(2,2))
print("a:", a)
cc = tf.data.Dataset.from_tensor_slices(a)
for i in cc:
     print("i: ", i)
输出：
a: [[7 3]
 [0 5]]
i:  tf.Tensor([7 3], shape=(2,), dtype=int32)
i:  tf.Tensor([0 5], shape=(2,), dtype=int32)

2.batch(batch_size, drop_remainder=False)：数据分批处理
batch_size:表示batch_size组数据为一批
drop_remainder：True表示剩下的数据不足batch_size个 仍掉。默认值为False

a = (1,2,3,4,5,6,7,8,9,11,12,13)
aa = tf.constant(a, shape=(6,2))
aa = tf.data.Dataset.from_tensor_slices(aa)
db = aa.batch(4, True)
for i in db:
    print("i: ", i)
输出结果：
i:  tf.Tensor(
[[1 2]
 [3 4]], shape=(2, 2), dtype=int32)
i:  tf.Tensor(
[[5 6]
 [7 8]], shape=(2, 2), dtype=int32)
i:  tf.Tensor(
[[ 9 11]
 [12 13]], shape=(2, 2), dtype=int32)

drop_remainder=True和False测试

a = (1,2,3,4,5,6,7,8,9,11,12,13)
aa = tf.constant(a, shape=(6,2))
aa = tf.data.Dataset.from_tensor_slices(aa)
db = aa.batch(batch_size=4, drop_remainder=False)
for i in db:
    print("i: ", i.numpy())
输出结果：
i:  [[1 2]
 [3 4]
 [5 6]
 [7 8]]
i:  [[ 9 11]
 [12 13]]
 
a = (1,2,3,4,5,6,7,8,9,11,12,13)
aa = tf.constant(a, shape=(6,2))
aa = tf.data.Dataset.from_tensor_slices(aa)
db = aa.batch(batch_size=4, drop_remainder=True)
for i in db:
    print("i: ", i.numpy())
输出结果：
i:  [[1 2]
 [3 4]
 [5 6]
 [7 8]]

3、np.repeat(n)

a = (1,2,3,4,5,6,7,8,9,10,11,12)
aa = tf.constant(a, shape=(6,2))
aa = tf.data.Dataset.from_tensor_slices(aa)
db = aa.batch(batch_size=2).repeat(2)
for i in db:
    print("i: ", i.numpy())
输出结果：
i:  [[1 2]
 [3 4]]
i:  [[5 6]
 [7 8]]
i:  [[ 9 10]
 [11 12]]
i:  [[1 2]
 [3 4]]
i:  [[5 6]
 [7 8]]
i:  [[ 9 10]
 [11 12]]

a = (1,2,3,4)
aa = tf.constant(a, shape=(2,2))
cc = aa.numpy().repeat(2)
print("cc: ",cc)
输出结果：
cc:  [1 1 2 2 3 3 4 4]

4.tf.nn.relu(features, name = None):这个函数的作用是计算激活函数 relu，即 max(features, 0)。即将矩阵中每行的非最大值置0

a = tf.random.normal([2,2])
print("a: ", a.numpy())
layer1 = tf.nn.relu(a)
print("layer1", layer1.numpy())
输出结果为：
a:  [[ 1.1811218   0.23751494]
 [-1.7438706  -1.8517566 ]]
layer1 [[1.1811218  0.23751494]
 [0.         0.        ]]

5.keras.layers.Dense这个全连接层封装了output = activation(tf.matmul(input, kernel) + bias)，其中，activation是用activation参数传递的逐元素激活函数，kernel是该层创建的权重矩阵，bias是由图层创建的偏差向量

units: 神经元节点数数，输出空间维度。
activation: 激活函数，若不指定，则不使用激活函数 (即线性激活: a(x) = x)。
use_bias: 布尔值，该层是否使用偏置向量。
kernel_initializer: kernel 权值矩阵的初始化器
bias_initializer: 偏置向量的初始化器
kernel_regularizer: 运用到 kernel 权值矩阵的正则化函数
bias_regularizer: 运用到偏置向的的正则化函数
activity_regularizer: 运用到层的输出的正则化函数 (它的 “activation”)。
kernel_constraint: 运用到 kernel 权值矩阵的约束函数
bias_constraint: 运用到偏置向量的约束函数

a = tf.random.normal([2,2])
print(a.shape)
layer1 = tf.keras.layers.Dense(4, activation='relu')
a = layer1(a)
print(a.shape)
输出结果为：
(2, 2)
(2, 4)

例子2：
input = tf.reshape(tf.constant([[1., 2.], [2., 3.]]), shape=[4, 1])
print('input: ',input)
dddd = tf.keras.layers.Dense(2, kernel_initializer=tf.constant_initializer(value=2), bias_initializer=tf.constant_initializer(value=1))
de = dddd(input)
print('de: ',de)

kernel = tf.reshape(tf.constant([2., 2.]), shape=[1, 2])
bias = tf.reshape(tf.constant([1., 1., 1., 1., 1., 1., 1., 1.]), shape=[4, 2])
b2 = tf.add(tf.matmul(input, kernel), bias)
print('b2:', b2)
输出：
de:  tf.Tensor(
[[3. 3.]
 [5. 5.]
 [5. 5.]
 [7. 7.]], shape=(4, 2), dtype=float32)
b2: tf.Tensor(
[[3. 3.]
 [5. 5.]
 [5. 5.]
 [7. 7.]], shape=(4, 2), dtype=float32)

6.model.fit( x, y, batch_size=32, epochs=10, verbose=1, callbacks=None,
validation_split=0.0, validation_data=None, shuffle=True,
class_weight=None, sample_weight=None, initial_epoch=0) 用于添加数据到模型，并且限定训练轮数

x：输入数据。如果模型只有一个输入，那么x的类型是numpy
array，如果模型有多个输入，那么x的类型应当为list，list的元素是对应于各个输入的numpy array
y：标签，numpy array
batch_size：整数，指定进行梯度下降时每个batch包含的样本数。训练时一个batch的样本会被计算一次梯度下降，使目标函数优化一步。
epochs：整数，训练终止时的epoch值，训练将在达到该epoch值时停止，当没有设置initial_epoch时，它就是训练的总轮数，否则训练的总轮数为epochs - inital_epoch
verbose：日志显示，0为不在标准输出流输出日志信息，1为输出进度条记录，2为每个epoch输出一行记录
callbacks：list，其中的元素是keras.callbacks.Callback的对象。这个list中的回调函数将会在训练过程中的适当时机被调用，参考回调函数
validation_split：0~1之间的浮点数，用来指定训练集的一定比例数据作为验证集。验证集将不参与训练，并在每个epoch结束后测试的模型的指标，如损失函数、精确度等。注意，validation_split的划分在shuffle之前，因此如果你的数据本身是有序的，需要先手工打乱再指定validation_split，否则可能会出现验证集样本不均匀。
validation_data：形式为（X，y）的tuple，是指定的验证集。此参数将覆盖validation_spilt。
shuffle：布尔值或字符串，一般为布尔值，表示是否在训练过程中随机打乱输入样本的顺序。若为字符串“batch”，则是用来处理HDF5数据的特殊情况，它将在batch内部将数据打乱。
class_weight：字典，将不同的类别映射为不同的权值，该参数用来在训练过程中调整损失函数（只能用于训练）

sample_weight：权值的numpy
array，用于在训练时调整损失函数（仅用于训练）。可以传递一个1D的与样本等长的向量用于对样本进行1对1的加权，或者在面对时序数据时，传递一个的形式为（samples，sequence_length）的矩阵来为每个时间步上的样本赋不同的权。这种情况下请确定在编译模型时添加了sample_weight_mode=’temporal’。

initial_epoch: 从该参数指定的epoch开始训练，在继续之前的训练时有用。

7.gradient求导

x = tf.constant(3.0)
with tf.GradientTape() as g:
  g.watch(x)
  with tf.GradientTape() as gg:
    gg.watch(x)
    y = x * x
  dy_dx = gg.gradient(y, x)     # Will compute to 6.0
d2y_dx2 = g.gradient(dy_dx, x)  # Will compute to 2.0

8.sparse_softmax_cross_entropy_with_logits：中 lables只能接受直接的数字标签
如[1], [2], [3], [4] （类型只能为int32，int64）。
logits应该是(batch,classes)的一个二维矩阵，classes为类别数量
labels应该是长（batch，)的一个一维矩阵

labels1=tf.constant([0,1,2,3,4],dtype=tf.int32)
logits=tf.Variable(tf.random.normal([5,6]))
result1 = tf.nn.sparse_softmax_cross_entropy_with_logits(labels=labels1, logits=logits)
print(result1)

输出结果：
tf.Tensor([2.456433  3.2039378 2.7502234 2.2304473 2.8621573], shape=(5,), dtype=float32)

9.tf.random.uniform：从均匀分布中生成随机值

s = tf.random.uniform([2])
print('s:',s)
输出：
s: tf.Tensor([0.3171562  0.11306894], shape=(2,), dtype=float32)

s = tf.random.uniform([2],2,3)
print('s:',s)
输出：
s: tf.Tensor([2.9321313 2.9326303], shape=(2,), dtype=float32)

10.tf.random.set_seed：设置全局随机种子

s = tf.random.uniform([2])
print('s:',s)
执行2次
第一次输出：
s: tf.Tensor([0.3171562  0.11306894], shape=(2,), dtype=float32)
第2次输出：
s: tf.Tensor([0.2171562  041306894], shape=(2,), dtype=float32)

两次结果不一样。

tf.random.set_seed(22)
s = tf.random.uniform([2])
print('s:',s)
第一次输出：
s: tf.Tensor([0.46031737 0.90100145], shape=(2,), dtype=float32)
第2次输出：
s: tf.Tensor([0.46031737 0.90100145], shape=(2,), dtype=float32)

两次结果一样。

“”"11. tf.keras.layers.Conv2D
filters: 卷积过滤器的数量,对应输出的维数–卷积核的数目（即输出的维度）

kernel_size:整数,过滤器的大小,如果为一个整数则宽和高相同.单个整数或由两个整数构成的list/tuple，卷积核的宽度和长度。如为单个整数，则表示在各个空间维度的相同长度

strides:横向和纵向的步长,如果为一个整数则横向和纵向相同.单个整数或由两个整数构成的list/tuple，为卷积的步长。如为单个整数，则表示在各个空间维度的相同步长。任何不为1的strides均与任何不为1的dilation_rata均不兼容。

padding:补0策略，为“valid”, “same”。“valid”代表只进行有效的卷积，即对边界数据不处理。“same”代表保留边界处的卷积结果，通常会导致输出shape与输入shape相同。

data_format:channels_last为(batch,height,width,channels),channels_first为(batch,channels,height,width).以128x128的RGB图像为例，“channels_first”应将数据组织为（3,128,128），而“channels_last”应将数据组织为
（128,128,3）。该参数的默认值是~/.keras/keras.json中设置的值，若从未设置过，则为“channels_last”。

dilation_rate:空洞卷积比例。作用如下：
1.扩大感受野。但需要明确一点，池化也可以扩大感受野，但空间分辨率降低了，相比之下，空洞卷积可以在扩大感受野的同时不丢失分辨率，且保持像素的相对空间位置不变。简单而言，空洞卷积可以同时控制感受野和分辨率。
2.获取多尺度上下文信息。当多个带有不同dilation rate的空洞卷积核叠加时，不同的感受野会带来多尺度信息，这对于分割任务是非常重要的。
3.可以降低计算量，不需要引入额外的参数，如上图空洞卷积示意图所示，实际卷积时只有带有红点的元素真正进行计算

activation:激活函数,如果不指定该参数，将不会使用任何激活函数（即使用线性激活函数：a(x)=x）

use_bias:是否使用偏差量,布尔值

kernel_initializer:卷积核的初始化。

bias_initializer:偏差向量的初始化。如果是None，则使用默认的初始值。

kernel_regularizer:卷积核的正则项

bias_regularizer:偏差向量的正则项

activity_regularizer:输出的正则函数

bias_constraint:映射函数，当偏差向量被Optimizer更新后应用到偏差向量上。"""

# The inputs are 28x28 RGB images with `channels_last` and the batch
# size is 4.
input_shape = (4, 28, 28, 3)
x = tf.random.normal(input_shape)
"""输入为(28,28),卷积核(F)的大小为3*3，pading(P)在这没有用，strides(S)步长默认为1。不带dilation_rate的计算公式out = ((input-F+2P)/S) + 1 = (28 - 3 + 0)/1  + 1 = 26
因此输出为(4,28,28,filters)
"""
y = tf.keras.layers.Conv2D(filters=5, kernel_size=3, activation='relu', input_shape=input_shape[1:])(x)
print(y.shape) #(4, 26, 26, 2)


input_shape = (4, 28, 28, 3)
x = tf.random.normal(input_shape)
"""带dilation_rate(D)的计算公式为：先计算F的新值：F = F+(F−1)∗(D−1) = 5,将新的F带入out = ((input-F+2P)/S) + 1 =（28 - 5 + 0）/1 + 1 = 24"""
y = tf.keras.layers.Conv2D(2, 3, activation='relu', dilation_rate=2, input_shape=input_shape[1:])(x)
print(y.shape) #(4, 24, 24, 2)

input_shape = (4, 28, 28, 3)
x = tf.random.normal(input_shape)
"""输入为(28,28),卷积核(F)的大小为3*3，pading(P)=same值为2，strides(S)步长默认为1。不带dilation_rate的计算公式out = ((input-F+2P)/S) + 1 = (28 - 3 + 2)/1  + 1 = 26
因此输出为(4,28,28,filters)
"""
y = tf.keras.layers.Conv2D(filters=5, kernel_size=3, padding = 'same' ,activation='relu', input_shape=input_shape[1:])(x)
print(y.shape) #(4, 28, 28, 5)


input_shape = (4, 7, 28, 28, 3)
x = tf.random.normal(input_shape)
y = tf.keras.layers.Conv2D(2, 3, activation='relu', input_shape=input_shape[2:])(x)
print(y.shape)#(4, 7, 26, 26, 2)

**12.tf.keras.metrics.CategoricalAccuracy()**计算预测值与一次标签匹配的匹配率。

m = tf.keras.metrics.CategoricalAccuracy()
m.update_state(y_true=[[0, 1, 0], [0, 1, 0]], y_pred=[[0.1, 0.9, 0.8],
                [0.05, 0.95, 0]])
print(m.result().numpy())#1.0
	
m = tf.keras.metrics.CategoricalAccuracy()
m.update_state(y_true=[[0, 0, 1], [0, 1, 0]], y_pred=[[0.1, 0.9, 0.8],
                [0.05, 0.95, 0]])
print(m.result().numpy())#0.5

13.tf.reduce_mean
第一个参数input_tensor： 输入的待降维的tensor;
第二个参数axis： 指定的轴，如果不指定，则计算所有元素的均值;
第三个参数keepdims：是否降维度，设置为True，输出的结果保持输入tensor的形状，设置为False，输出结果会降低维度;
第四个参数name： 操作的名称;

x = [[1, 2, 3],
     [5, 6, 7]]

xx = tf.cast(x, tf.float32)
print(xx)
mean_all = tf.reduce_mean(xx, keepdims=False)#计算所有数的平均值
mean_0 = tf.reduce_mean(xx, axis=0, keepdims=False)#计算y的平均值
mean_1 = tf.reduce_mean(xx, axis=1, keepdims=False)#计算x轴的平均值

print(mean_all)  # output: 4.0 = (1+2+3++5+6+7)/6
print(mean_0)  # output: [ 3=(1+5)/2.  4=(2+6)/2.  5=(3+7)/2.]
print(mean_1)  # output:  [ 2=(1+2+3)/3.  6=(5+6+7)/3.]
输出：

tf.Tensor(4.0, shape=(), dtype=float32)
tf.Tensor([3. 4. 5.], shape=(3,), dtype=float32)
tf.Tensor([2. 6.], shape=(2,), dtype=float32)

keepdims为True的情况：

x = [[1, 2, 3],
     [5, 6, 7]]

xx = tf.cast(x, tf.float32)
print(xx)
mean_all = tf.reduce_mean(xx, keepdims=True)#计算所有数的平均值
mean_0 = tf.reduce_mean(xx, axis=0, keepdims=True)#计算y的平均值
mean_1 = tf.reduce_mean(xx, axis=1, keepdims=True)#计算x轴的平均值

print(mean_all)
print(mean_0) 
print(mean_1)
输出：
tf.Tensor([[4.]], shape=(1, 1), dtype=float32)
tf.Tensor([[3. 4. 5.]], shape=(1, 3), dtype=float32)
tf.Tensor(
[[2.]
 [6.]], shape=(2, 1), dtype=float32)

14.tf.keras.layers.GlobalAveragePooling2D全局平均池化.前后的尺寸分别为[B,H,W,C]->[B,C].特别要注意。

input_shape = (3, 2, 2, 5)
input = tf.random.uniform(input_shape,1,5)
print(input)
cc = tf.keras.layers.GlobalAveragePooling2D()
print(cc(input))

输出：
tf.Tensor(
[[[[1.8904896 1.4346223 1.6720557 4.4227915 4.2653813]
   [2.7237763 2.9677105 1.5450516 3.9503422 1.0435939]]

  [[1.9149103 1.584486  4.019026  4.9667344 1.0931883]
   [3.046763  3.2893333 1.409277  2.2813087 3.4627423]]]


 [[[3.2393527 2.348177  1.4723015 3.8350492 2.3949609]
   [1.1826615 4.31842   2.6642933 2.8260217 4.739408 ]]

  [[3.482617  1.3776608 4.904896  4.079719  2.0379791]
   [2.3100877 2.736185  1.642602  1.1818748 4.8426332]]]


 [[[2.7163606 4.201116  2.44036   3.5281978 2.4551864]
   [3.5421553 2.7841787 3.3077211 1.4128575 4.72965  ]]

  [[1.8924403 4.5091085 2.1991735 3.1931033 2.0195699]
   [4.3158765 3.2073717 3.9069257 1.784646  1.8854799]]]], shape=(3, 2, 2, 5), dtype=float32)
tf.Tensor(
[[2.3939848 2.319038  2.1613526 3.9052944 2.4662266]
 [2.5536797 2.6951108 2.6710231 2.9806662 3.5037453]
 [3.1167083 3.675444  2.963545  2.4797013 2.7724717]], shape=(3, 5), dtype=float32)
值如何计算的，举例，如下：
2.3939848 = (1.8904896+2.7237763+1.9149103+3.046763)/4 其他值类似计算