一、自动求导机制
tf.GradientTape是eager模式下计算梯度用的。
watch(tensor)
作用：确保某个tensor被tape追踪
参数:tensor: 一个Tensor或者一个Tensor列表
gradient(target, sources)
作用：根据tape上面的上下文来计算某个或者某些tensor的梯度参数
target: 被微分的Tensor或者Tensor列表，你可以理解为经过某个函数之后的值
sources: Tensors 或者Variables列表（当然可以只有一个值）. 你可以理解为函数的某个变量
返回:
一个列表表示各个变量的梯度值，和source中的变量列表一一对应，表明这个变量的梯度。
简单的示例：
x = tf.constant(3.0)
#求y=x^2在x=3时的导数
with tf.GradientTape() as g: #这个g相当于给这个方法起个名字
g.watch(x)
y = x * x
dy_dx = g.gradient(y, x)
二、模型自动求导
模型大致的顺序为：构建模型（神经网络的前向传播） --> 定义损失函数 --> 定义优化函数 --> 定义tape --> 模型得到预测值 --> 前向传播得到loss --> 反向传播 --> 用优化函数将计算出来的梯度更新到变量上面去
全连接神经网络正向传播以及反向传播算法推导
总之，要用损失函数计算的误差对权重求导得到梯度，再用优化器将梯度更新到权重上。
class MyModel(tf.keras.Model):
def __init__(self, num_classes=10):
super(MyModel, self).__init__(name='my_model')
self.num_classes = num_classes
# 定义自己需要的层
self.dense_1 = tf.keras.layers.Dense(32, activation='relu') #隐藏层
self.dense_2 = tf.keras.layers.Dense(num_classes)#输出层
def call(self, inputs):
#定义前向传播
# 使用在 (in `__init__`)定义的层
x = self.dense_1(inputs)
return self.dense_2(x)
import numpy as np
# 10分类问题
data = np.random.random((1000, 32))
labels = np.random.random((1000, 10))
model = MyModel(num_classes=10)
loss_object = tf.keras.losses.CategoricalCrossentropy(from_logits=True)
optimizer = tf.keras.optimizers.Adam()
with tf.GradientTape() as tape:
predictions = model(data) #输入训练集，得到预测值
loss = loss_object(labels, predictions) #通过损失函数计算误差
gradients = tape.gradient(loss, model.trainable_variables) #误差对权重求导，得到梯度
optimizer.apply_gradients(zip(gradients, model.trainable_variables)) #更新权重
三、使用GradientTape自定义训练模型
class MyModel(tf.keras.Model):
def __init__(self, num_classes=10):
super(MyModel, self).__init__(name='my_model')
self.num_classes = num_classes
# 定义自己需要的层
self.dense_1 = tf.keras.layers.Dense(32, activation='relu')
self.dense_2 = tf.keras.layers.Dense(num_classes)
def call(self, inputs):
#定义前向传播
# 使用在 (in `__init__`)定义的层
x = self.dense_1(inputs)
return self.dense_2(x)
import numpy as np
data = np.random.random((1000, 32))
labels = np.random.random((1000, 10))
model = MyModel(num_classes=10)
#优化器
optimizer = tf.keras.optimizers.SGD(learning_rate=1e-3)
#损失函数
loss_fn = tf.keras.losses.CategoricalCrossentropy()
#训练集
batch_size = 64
train_dataset = tf.data.Dataset.from_tensor_slices((data, labels))
train_dataset = train_dataset.shuffle(buffer_size=1024).batch(batch_size)
epochs = 3
for epoch in range(epochs):
print('Start of epoch %d' % (epoch,))
# 遍历数据集的batch_size
for step, (x_batch_train, y_batch_train) in enumerate(train_dataset):
'''
这里step，x_batch_train,y_batch_train,分别代表
enumerate(train_dataset)中的序号、64(即batch_size)个data(当然一个data是32列),64个labels(一个label是10列)
'''
# 打开GradientTape以记录正向传递期间运行的操作，这将启用自动区分。
with tf.GradientTape() as tape:
# 运行该模型的前向传播。 模型应用于其输入的操作将记录在GradientTape上。
logits = model(x_batch_train, training=True) # 这个minibatch的预测值
# 计算这个minibatch的损失值
loss_value = loss_fn(y_batch_train, logits)
# 使用GradientTape自动获取可训练变量相对于损失的梯度。
grads = tape.gradient(loss_value, model.trainable_weights)
# 更新权重
optimizer.apply_gradients(zip(grads, model.trainable_weights))
# 每200 batches打印一次.
if step % 200 == 0:
print('Training loss (for one batch) at step %s: %s' % (step, float(loss_value)))
print('Seen so far: %s samples' % ((step + 1) * 64))
tf.data.Dataset.from_tensor_slices可以实现输入张量的自动切片。
tensorFlow2.1下的tf.data.Dataset.from_tensor_slices()和batch()的用法
.shuffle用于打乱数据，防止出现过拟合现象。buffer_size=1024代表从data数据集中顺序抽取1024个数据进行打乱。后面的.batch(batch_size)就是从这些已经打乱的数据中取出batch_size个。
.batch用于将已经切片好的数据按照每次batch_size的数量按顺序取出。
TensorFlow dataset.shuffle、batch、repeat用法
enumerate的作用就是对可迭代的数据进行标号并将其里面的数据和标号一并打印出来。
enumerate的用法
>>> seq = 'hello'
>>> for i,key in enumerate(seq):
print 'seq[%d]=%s' % (i, key)
输出：
...
seq[0]=h
seq[1]=e
seq[2]=l
seq[3]=l
seq[4]=o
zip函数返回一个zip对象，它是元组的迭代器，其中传递的每个迭代器中的第一个元素成对，然后传递的每个迭代器中的第二个元素成对等等。
zip函数详解
四、加入评估函数
要点：
在循环开始时初始化metrics
metric.update_state():每batch之后更新
metric.result():需要显示metrics的当前值时调用
metric.reset_states():需要清除metrics状态时重置（通常在每个epoch的结尾
class MyModel(tf.keras.Model):
def __init__(self, num_classes=10):
super(MyModel, self).__init__(name='my_model')
self.num_classes = num_classes
# 定义自己需要的层
self.dense_1 = tf.keras.layers.Dense(32, activation='relu')
self.dense_2 = tf.keras.layers.Dense(num_classes)
def call(self, inputs):
#定义前向传播
# 使用在 (in `__init__`)定义的层
x = self.dense_1(inputs)
return self.dense_2(x)
import numpy as np
x_train = np.random.random((1000, 32))
y_train = np.random.random((1000, 10))
x_val = np.random.random((200, 32))
y_val = np.random.random((200, 10))
x_test = np.random.random((200, 32))
y_test = np.random.random((200, 10))
# 优化器
optimizer = tf.keras.optimizers.SGD(learning_rate=1e-3)
# 损失函数
loss_fn = tf.keras.losses.CategoricalCrossentropy(from_logits=True)
# 准备metrics函数
train_acc_metric = tf.keras.metrics.CategoricalAccuracy()
val_acc_metric = tf.keras.metrics.CategoricalAccuracy()
# 准备训练数据集
batch_size = 64
train_dataset = tf.data.Dataset.from_tensor_slices((x_train, y_train))
train_dataset = train_dataset.shuffle(buffer_size=1024).batch(batch_size)
# 准备测试数据集
val_dataset = tf.data.Dataset.from_tensor_slices((x_val, y_val))
val_dataset = val_dataset.batch(64)
model = MyModel(num_classes=10)
epochs = 3
for epoch in range(epochs):
print('Start of epoch %d' % (epoch,))
# 遍历数据集的batch_size
for step, (x_batch_train, y_batch_train) in enumerate(train_dataset):
#一个batch
with tf.GradientTape() as tape:
logits = model(x_batch_train)
loss_value = loss_fn(y_batch_train, logits)
grads = tape.gradient(loss_value, model.trainable_weights)
optimizer.apply_gradients(zip(grads, model.trainable_weights))####
# 更新训练集的metrics
train_acc_metric(y_batch_train, logits)
# 在每个epoch结束时显示metrics。
train_acc = train_acc_metric.result()
print('Training acc over epoch: %s' % (float(train_acc),))
# 在每个epoch结束时必须重置训练指标
train_acc_metric.reset_states()
# 在每个epoch结束时运行一个验证集。
for x_batch_val, y_batch_val in val_dataset:
val_logits = model(x_batch_val)
# 更新验证集merics
val_acc_metric(y_batch_val, val_logits)
val_acc = val_acc_metric.result()
print('Validation acc: %s' % (float(val_acc),))
val_acc_metric.reset_states() #重置
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
