详解TensorFlow训练网络两种方式

TensorFlow训练网络有两种方式，一种是基于tensor(array)，另外一种是迭代器

• 第一种是要加载全部数据形成一个tensor，然后调用model.fit()然后指定参数batch_size进行将所有数据进行分批训练
• 第二种是自己先将数据分批形成一个迭代器，然后遍历这个迭代器，分别训练每个批次的数据

方式一：通过迭代器

```IMAGE_SIZE = 1000

# step1:加载数据集
(train_images, train_labels), (val_images, val_labels) = tf.keras.datasets.mnist.load_data()

# step2:将图像归一化
train_images, val_images = train_images / 255.0, val_images / 255.0

# step3:设置训练集大小
train_images = train_images[:IMAGE_SIZE]
val_images = val_images[:IMAGE_SIZE]
train_labels = train_labels[:IMAGE_SIZE]
val_labels = val_labels[:IMAGE_SIZE]

# step4:将图像的维度变为(IMAGE_SIZE,28,28,1)
train_images = tf.expand_dims(train_images, axis=3)
val_images = tf.expand_dims(val_images, axis=3)

# step5:将图像的尺寸变为(32,32)
train_images = tf.image.resize(train_images, [32, 32])
val_images = tf.image.resize(val_images, [32, 32])

# step6:将数据变为迭代器

# step5:导入模型
model = LeNet5()

# 让模型知道输入数据的形式
model.build(input_shape=(1, 32, 32, 1))

# 结局Output Shape为 multiple
model.call(Input(shape=(32, 32, 1)))

# step6:编译模型
loss=tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True),
metrics=['accuracy'])

# 权重保存路径
checkpoint_path = "./weight/cp.ckpt"

# 回调函数，用户保存权重
save_callback = tf.keras.callbacks.ModelCheckpoint(filepath=checkpoint_path,
save_best_only=True,
save_weights_only=True,
monitor='val_loss',
verbose=0)

EPOCHS = 11

for epoch in range(1, EPOCHS):
# 每个批次训练集误差
train_epoch_loss_avg = tf.keras.metrics.Mean()
# 每个批次训练集精度
train_epoch_accuracy = tf.keras.metrics.SparseCategoricalAccuracy()
# 每个批次验证集误差
val_epoch_loss_avg = tf.keras.metrics.Mean()
# 每个批次验证集精度
val_epoch_accuracy = tf.keras.metrics.SparseCategoricalAccuracy()

history = model.fit(x,
y,
callbacks=[save_callback],
verbose=0)

# 更新误差，保留上次
train_epoch_loss_avg.update_state(history.history['loss'][0])
# 更新精度，保留上次
train_epoch_accuracy.update_state(y, model(x, training=True))

val_epoch_loss_avg.update_state(history.history['val_loss'][0])

# 使用.result()计算每个批次的误差和精度结果
print("Epoch {:d}: trainLoss: {:.3f}, trainAccuracy: {:.3%} valLoss: {:.3f}, valAccuracy: {:.3%}".format(epoch,
train_epoch_loss_avg.result(),
train_epoch_accuracy.result(),
val_epoch_loss_avg.result(),
val_epoch_accuracy.result()))```

方式二：适用model.fit()进行分批训练

```import model_sequential

(train_images, train_labels), (test_images, test_labels) = tf.keras.datasets.mnist.load_data()

# step2:将图像归一化
train_images, test_images = train_images / 255.0, test_images / 255.0

# step3:将图像的维度变为(60000,28,28,1)
train_images = tf.expand_dims(train_images, axis=3)
test_images = tf.expand_dims(test_images, axis=3)

# step4:将图像尺寸改为(60000,32,32,1)
train_images = tf.image.resize(train_images, [32, 32])
test_images = tf.image.resize(test_images, [32, 32])

# step5:导入模型
# history = LeNet5()
history = model_sequential.LeNet()

# 让模型知道输入数据的形式
history.build(input_shape=(1, 32, 32, 1))
# history(tf.zeros([1, 32, 32, 1]))

# 结局Output Shape为 multiple
history.call(Input(shape=(32, 32, 1)))
history.summary()

# step6:编译模型
loss=tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True),
metrics=['accuracy'])

# 权重保存路径
checkpoint_path = "./weight/cp.ckpt"

# 回调函数，用户保存权重
save_callback = tf.keras.callbacks.ModelCheckpoint(filepath=checkpoint_path,
save_best_only=True,
save_weights_only=True,
monitor='val_loss',
verbose=1)
# step7:训练模型
history = history.fit(train_images,
train_labels,
epochs=10,
batch_size=32,
validation_data=(test_images, test_labels),
callbacks=[save_callback])```