Tensorflow2.0 Resnet18与cifar100

最新推荐文章于 2025-02-02 09:00:00 发布

原创最新推荐文章于 2025-02-02 09:00:00 发布 · 1.2k 阅读

10 ·

CC 4.0 BY-SA版权

TensorFlow 专栏收录该内容

70 篇文章

订阅专栏

Resnet结构
在这里插入图片描述
详细结构

具体代码实现准确率 42%左右

网络结构代码:

import tensorflow as tf
from tensorflow.keras import layers, Sequential


# 基础卷积单元网络
# conv + bn + relu
class BasicBlock(layers.Layer):
    def __init__(self, filter_num, stride=1):
        """
        :param filter_num: 卷积核的个数
        :param stride: 步长
        """
        super(BasicBlock, self).__init__()

        # 卷积层 1 可能会做 下采样
        self.conv1 = layers.Conv2D(filter_num, (3, 3),
                                   strides=stride, padding="same")
        self.bn1 = layers.BatchNormalization()
        self.relu = layers.Activation("relu")

        # 卷积层2 不做下采样
        self.conv2 = layers.Conv2D(filter_num, (3, 3),
                                   strides=1, padding="same")
        self.bn2 = layers.BatchNormalization()

        if stride != 1:  # 是否使用 下采样
            # 下采样
            self.down_sample = Sequential()
            # 可能会做下采样
            self.down_sample.add(layers.Conv2D(filter_num, (1, 1), strides=stride))
            self.down_sample.add(layers.BatchNormalization())
        else:
            # 不做下采样
            self.down_sample = lambda x: x

        self.stride = stride  # 步长

    def call(self, inputs, training=None):
        # 残差边 根据stride（下采样 或 不做处理）
        identity = self.down_sample(inputs)

        # 卷积边
        # 层1 卷积 + 正则化 + relu层
        out = self.conv1(inputs)  # 根据stride（下采样 或 不做处理）
        out = self.bn1(out)
        out = self.relu(out)

        # 层2 卷积 + 正则化
        out = self.conv2(out)
        out = self.bn2(out)

        # 卷积边 + 残差边
        out_put = layers.add([out, identity])
        # relu 函数
        out_put = tf.nn.relu(out_put)

        return out_put


# ResNet 网络的创建
class ResNet(tf.keras.Model):
    def __init__(self, layer_dims, num_classes=100):  # [2, 2, 2, 2]
        # layer_dims 层的维度  18:[2 * res_block, 2 * res_block, 2 * res_block, 2 * res_block]
        # 34:[3, 4, 6, 3]
        super(ResNet, self).__init__()
        self.stem = Sequential([layers.Conv2D(64, (3, 3), strides=(1, 1)),
                                layers.BatchNormalization(),
                                layers.Activation("relu"),
                                layers.MaxPool2D(pool_size=(2, 2), strides=(1, 1), padding="same")
                                ])
        # 2个block
        self.layer1 = self.build_res_block(64, layer_dims[0])
        # 2个block 下采样一次
        self.layer2 = self.build_res_block(128, layer_dims[1], stride=2)
        # 2个block 下采样一次
        self.layer3 = self.build_res_block(256, layer_dims[2], stride=2)
        # 2个block 下采样一次
        self.layer4 = self.build_res_block(512, layer_dims[3], stride=2)

        # output:[b, 512, h, w] ==> 全局均值池化
        self.avg_pool = layers.GlobalAveragePooling2D()
        # 全链接层
        self.fc = layers.Dense(num_classes)

    def call(self, inputs, training=None):
        # 前向运算
        # 初步处理
        x = self.stem(inputs)
        # 四层的叠加
        x = self.layer1(x)
        x = self.layer2(x)
        x = self.layer3(x)
        x = self.layer4(x)

        # [b, c] 全局均值池化
        x = self.avg_pool(x)
        # [b, 100] 全连接层
        x = self.fc(x)
        return x

    # 基本单元块
    @staticmethod
    def build_res_block(filter_num, blocks, stride=1):
        res_blocks = Sequential()

        # 可能下采样
        res_blocks.add(BasicBlock(filter_num, stride))

        for _ in range(1, blocks):
            # 不做下采样
            res_blocks.add(BasicBlock(filter_num, stride=1))
        return res_blocks


# resnet 18 层
def resnet18():
    return ResNet([2, 2, 2, 2])


# resnet 34 层
def resnet34():
    return ResNet([3, 4, 6, 3])

网络训练与测试

"""
    cifar100数据集处理
    使用 Resnet18、Resnet34 网络层
"""
import os

import tensorflow as tf
from tensorflow.keras import datasets, optimizers

from resnet import resnet18

os.environ["TF_CPP_MIN_LOG_LEVEL"] = "2"
tf.random.set_seed(2345)

# GPU设置
gpu_lst = tf.config.experimental.list_physical_devices("GPU")
print("GPU:{}个".format(len(gpu_lst)))

for gpu in gpu_lst:
    tf.config.experimental.set_memory_growth(gpu, True)  # GPU自增长


# 1.load data_sets   数据集的加载
def pre_process(x_data, y_data):
    # 数据范围 (0-255) ==> (0-1])
    x_data = 2 * tf.cast(x_data, dtype=tf.float32) / 255. - 1
    # 数据类型 tf.int32  y:(0-99)
    y_data = tf.cast(y_data, dtype=tf.int32)
    return x_data, y_data


# 加载默认数据集:cifar-100
(x, y), (x_test, y_test) = datasets.cifar100.load_data()
# y (50000,1) ==>(50000,)
y = tf.squeeze(y, axis=1)

# y_test (10000,1) ==>(10000,)
y_test = tf.squeeze(y_test, axis=1)

print(x.shape, y.shape, x_test.shape, y_test.shape)

# 训练集 dataset 数据集生成(做简单的预处理 + batch)
train_db = tf.data.Dataset.from_tensor_slices((x, y))
train_db = train_db.shuffle(10000).map(pre_process).batch(128)

# 测试集 dataset 数据集生成(做简单的预处理 + batch)
test_db = tf.data.Dataset.from_tensor_slices((x_test, y_test))
test_db = test_db.map(pre_process).batch(64)

# 数据维度确认
sample = next(iter(train_db))
# x，y的维度   x的最小值与最大值
print("sample:", sample[0].shape, sample[1].shape,
      tf.reduce_min(sample[0]), tf.reduce_max(sample[0]))


# 2.build network 构建网络结构与创建
def main():
    # 创建网络结构
    model = resnet18()

    # x = tf.random.normal([4, 32, 32, 3])
    # resnet18 网络的创建
    model.build(input_shape=(None, 32, 32, 3))

    # 设置优化器
    optimizer = optimizers.Adam(lr=1e-4)
    model.summary()

    # 3.Train  循环训练
    for epoch in range(50):
        for step, (x, y) in enumerate(train_db):

            with tf.GradientTape() as tape:
                # 前向传播
                # [b, 32, 32,3] => [b, 100]
                y_prd = model(x)

                # [b,] => [b, 100]
                y_true = tf.one_hot(y, depth=100)

                # 损失函数计算
                loss = tf.losses.categorical_crossentropy(y_true, y_prd, from_logits=True)
                loss = tf.reduce_mean(loss)
            # 梯度计算
            grads = tape.gradient(loss, model.trainable_variables)
            # 优化器更新参数
            optimizer.apply_gradients(zip(grads, model.trainable_variables))

            # 打印结果
            if step % 100 == 0:
                print(epoch, step, "loss:", float(loss))

        # 4.Test 计算正确率
        total_num = 0
        total_correct = 0
        for x, y in test_db:
            # 前向传播
            y_prd = model(x)
            prob = tf.nn.softmax(y_prd, axis=1)
            pred = tf.argmax(prob, axis=1)
            pred = tf.cast(pred, dtype=tf.int32)

            # 计算正确数
            # [b, bool] ==> [b, int32]
            correct = tf.cast(tf.equal(pred, y), dtype=tf.int32)
            correct = tf.reduce_sum(correct)

            # 累加总数与正确数
            total_num += x.shape[0]
            total_correct += int(correct)

        # 计算正确率
        acc = total_correct / total_num
        print(epoch, "acc:", acc)


if __name__ == '__main__':
    main()