Tensorflow2.0 keras Metrics的基本使用

Metrics的基本使用

1. Metrics 创建并设置数据模式
2. update_state 添加数据
3. result().numpy() 获取结果
4. reset_states 清空数据

步骤1 ：创建meter 测量值处理

acc_meter = metrics.Accuracy()  # 正确率的计算
loss_meter = metrics.Mean()	# 求均值(传入损失值)

步骤2 ： 更新数据(添加)

acc_meter.update_state(y_true, predict)	# 正确率传入数据
loss_meter.update_state(loss) # 损失值均值

步骤3：获取结果数据

print(step, "loss", loss_meter.result().numpy())	# 获取损失均值
print(step, "Evaluate Acc:", acc_meter.result().numpy()) # 获取正确率

步骤4：清空缓存

# 每步添加损失值
if step % 100 == 0:
	print(step, "loss", loss_meter.result().numpy())	# 获取损失均值
	loss_meter.reset_states()
if step % 500 == 0:
    print(step, "Evaluate Acc:", acc_meter.result().numpy()) # 获取正确率
    acc_meter.reset_states()

测试使用

import tensorflow as tf
import numpy as np

# 获取物理GPU的个数
gpus = tf.config.experimental.list_physical_devices("GPU")
for gpu in gpus:
    # 设置内存增长方式 自增长
    tf.config.experimental.set_memory_growth(gpu, True)
print("物理GPU个数:", len(gpus))

batch_size = 128

# 导入数据集
(x_train, y_train), (x_test, y_test) = tf.keras.datasets.mnist.load_data()
print(x_train.shape, y_train.shape, x_test.shape, y_test.shape)


# 数据的预处理
def pre_process(x, y):
    x = tf.cast(x, tf.float32) / 255.0
    y = tf.cast(y, tf.int32)
    return x, y


# 数据映射 打乱 分批 重复处理
db_train = tf.data.Dataset.from_tensor_slices((x_train, y_train))
db_train = db_train.map(pre_process).shuffle(60000).batch(batch_size).repeat(10)

db_test = tf.data.Dataset.from_tensor_slices((x_test, y_test))
db_test = db_test.map(pre_process).batch(batch_size)

db_sample = iter(db_train)
sample = next(db_sample)
print("X:", sample[0].shape, "Y:", sample[1].shape)

# 创建网络
model = tf.keras.Sequential([tf.keras.layers.Dense(256, activation="relu"),
                             tf.keras.layers.Dense(128, activation="relu"),
                             tf.keras.layers.Dense(64, activation="relu"),
                             tf.keras.layers.Dense(32, activation="relu"),
                             tf.keras.layers.Dense(10)])
model.build(input_shape=(None, 28 * 28))
model.summary()

# 优化器
optimizer = tf.keras.optimizers.Adam(lr=0.001)

# 正确率统计
acc_meter = tf.keras.metrics.Accuracy()
loss_meter = tf.keras.metrics.Mean()

for step, (x_batch, y_batch) in enumerate(db_train):

    # 前向传播
    with tf.GradientTape() as tape:
        # 前向传播准备
        x_batch = tf.reshape(x_batch, (-1, 28 * 28))
        y_one_hot = tf.one_hot(y_batch, depth=10)

        # 前向传播
        y_out = model(x_batch)

        # 计算损失函数
        loss = tf.reduce_mean(tf.losses.categorical_crossentropy(y_one_hot, y_out, from_logits=True))
        loss_meter.update_state(loss)
    # 更新梯度
    grads = tape.gradient(loss, model.trainable_variables)
    optimizer.apply_gradients(zip(grads, model.trainable_variables))

    # 显示损失函数  并重置
    if step % 100 == 0:
        print(step, "loss:", loss_meter.result().numpy())
        loss_meter.reset_states()

    if step % 500 == 0:
        # 手动统计
        total, total_correct = 0., 0.0
        # 准确率重置
        acc_meter.reset_states()

        for _, (x_test_batch, y_test_batch) in enumerate(db_test):

            x_test_batch = tf.reshape(x_test_batch, (-1, 28 * 28))

            y_test_out = model(x_test_batch)
            y_test_out = tf.argmax(y_test_out, axis=1)
            predict = tf.cast(y_test_out, dtype=tf.int32)

            # 手动计算准确率
            correct = tf.equal(predict, y_test_batch)
            total_correct += tf.reduce_sum(tf.cast(correct, tf.int32)).numpy()
            total += x_test_batch.shape[0]

            # 更新准确率数据
            acc_meter.update_state(y_test_batch, predict)

        # 显示准确率
        acc = total_correct/total
        print(step, "Acc", acc, acc_meter.result().numpy())