深度学习-Tensorflow2.2-Eager模式与自定义训练{4}-微分运算训练练习-16

Eager模式简介

Tensorflow 发布了新的 TF 2.0 Beta 版本我们可以通过以下命令安装：pip install tensorflow==2.0.0-beta1

TensorFlow的eager模式是一个命令式编程环境，它使得我们可以立即评估操作产生的结果，而无需构建计 算图。

Eager模式极大的方便我们使用TensorFlow、调试模型，增加了网络调试的灵活程度和tensorflow对于初学者友好性。

在这里我们可以叫它 tensorflow的交互模式。

与Tensorflow 1.x版本不同，tensorflow 2.0 默认使用 eager 模式。
执行tf.executing_eagerly() 返回 True

Eager模式提供了一个灵活的研究和实验机器学习平台，提供直观的界面 - 自然地构建代码并使用Python数据结构。快速迭代小型模型和小型数据。

更容易调试 -在交互式环境中直接检查、运行模型、测试变化。这个过程中代码会即时错误报告。

自然控制流 - eager模式下使用Python控制流而不是图控制流，简化了动态模型的创建。

Eager模式支持大多数TensorFlow操作和GPU加速。

eager模式下，TensorFlow操作会立即执行并将其值返回给Python。

tf.Tensor对象引用具体值而不是计算图中节点的符号句柄。

Eager模式运行特点

由于在会话中没有构建和运行的计算图，因此使用print()语句或调试器很容易检查结果、评估输出，打印和检查张量值，而不影响计算梯度的过程。

Eager模式下Tensorflow可与NumPy很好地协作。

TensorFlow 数学运算可将Python对象和NumPy数组转换为tf.Tensor对象。

而 tf.Tensor.numpy方法将对象的值作NumPy返回ndarray。

Eager模式中梯度的计算

在Eager模式中，使用tf.GradientTape跟踪计算梯度的操作

由于在每次执行可能发生不同的操作，所有前向传递操作都被记录到Tape上。要计算渐变，就往后播放磁带
然后丢弃。

特定的tf.GradientTape只能计算一个梯度; 后续调用会引发运行时错误。

也可以设置可重复调用

张量

自动微分

自定义训练

import tensorflow as tf

(train_image,train_labels),_=tf.keras.datasets.mnist.load_data()

train_image.shape,train_labels

train_image = tf.expand_dims(train_image,-1)# 扩充维度
train_image.shape

# 改变数据类型
train_image = tf.cast(train_image/255,tf.float32) # 归一化并改变数据类型
train_labels = tf.cast(train_labels,tf.int64)

dataset = tf.data.Dataset.from_tensor_slices((train_image,train_labels)) # 建立数据集
dataset

dataset = dataset.shuffle(10000).batch(32) # 对数据进行洗牌 乱序
dataset

# 建立模型
model = tf.keras.Sequential([
    tf.keras.layers.Conv2D(16,[3,3],activation="relu",input_shape=(28,28,1)),
    tf.keras.layers.Conv2D(32,[3,3],activation="relu"),
    tf.keras.layers.GlobalAveragePooling2D(),
    tf.keras.layers.Dense(10) # 未激活
])

# 自定义循环（编译）
optimizers = tf.keras.optimizers.Adam() # 优化函数
loss_func = tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True) # 损失函数

features,labels = next (iter(dataset))
features.shape,labels.shape

predictions = model(features)
predictions.shape

tf.argmax(predictions,axis=1)

labels

def loss(model,x,y):
    y_ = model(x)
    return loos_func(y,y_)

def train_step(model,images,labels):
    with tf.GradientTape() as t:
        loss_step = loss(model,images,labels)
    grads = t.gradient(loss_step,model.trainable_variables)
    optimizers.apply_gradients(zip(grads,model.trainable_variables))

def train():
    for epoch in range(10):
        for (batch,(images,labels)) in enumerate(dataset):
            train_step(model,images,labels)
        print("epoch{} is finshed".format(epoch))

train()

代码如下：

import tensorflow as tf
import os
os.environ['TF_CPP_MIN_LOG_LEVEL'] = '2' # 修改警告级别，不显示警告



(train_image,train_labels),_=tf.keras.datasets.mnist.load_data()
print(train_image.shape,train_labels)
train_image = tf.expand_dims(train_image,-1)# 扩充维度
print(train_image.shape)
# 改变数据类型
train_image = tf.cast(train_image/255,tf.float32) # 归一化并改变数据类型
train_labels = tf.cast(train_labels,tf.int64)
dataset = tf.data.Dataset.from_tensor_slices((train_image,train_labels)) # 建立数据集
dataset = dataset.shuffle(10000).batch(32) # 对数据进行洗牌
print(dataset)
# 建立模型
model = tf.keras.Sequential([
    tf.keras.layers.Conv2D(16,[3,3],activation="relu",input_shape=(28,28,1)),
    tf.keras.layers.Conv2D(32,[3,3],activation="relu"),
    tf.keras.layers.GlobalAveragePooling2D(),
    tf.keras.layers.Dense(10) # 未激活
])
# 自定义循环（编译）
optimizers = tf.keras.optimizers.Adam() # 优化函数
loss_func = tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True) # 损失函数
features,labels = next (iter(dataset))
print(features.shape,labels.shape)
predictions = model(features)
print(predictions.shape)
tf.argmax(predictions,axis=1)
print(labels)

def loss(model,x,y):
    y_ = model(x)
    return loss_func(y,y_)

train_loss = tf.keras.metrics.Mean("train_loss")
train_accuracy = tf.keras.metrics.SparseCategoricalAccuracy("train_accuracy")

def train_step(model,images,labels):
    with tf.GradientTape() as t:
        pred = model(images)
        loss_step = loss_func(labels,pred)
    grads = t.gradient(loss_step,model.trainable_variables)
    optimizers.apply_gradients(zip(grads,model.trainable_variables))
    train_loss(loss_step)
    train_accuracy(labels,pred)
def train():
    for epoch in range(10):
        for (batch,(images,labels)) in enumerate(dataset):
            train_step(model,images,labels)
        print("epoch{} loss is {},acc is {}".format(epoch,
                                                    train_loss.result(),
                                                    train_accuracy.result()))
        train_loss.reset_states()# 重置状态
        train_accuracy.reset_states()


train()