深度学习_10_3_CIFAR100与VGG13实战

10_3_CIFAR100与VGG13实战

CIFAR100

与CIFAR10图片不变，但是分为10大类和每大类10小类。

• 32*32
• 60K：50K+10K

Pipline（流程）

• Load datasets加载数据集
• Build Network创建网络
• Train
• Test

13 Layers

conv * 2+max pool = 一小块

最后得到1*1*512，再送到一个全连接层（1层），再送到输出（1层）

源代码

import os
os.environ['TF_CPP_MIN_LOG_LEVEL'] = '2'

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

tf.random.set_seed(2345)

conv_layers = [ # units of conv + max pooling
    # unit 1
    #64个核；kernel size常用1,3,5
    #padding是使输出维度=输入维度；activation激活函数，卷积完成后做
    layers.Conv2D(64,kernel_size=[3,3],padding="same",activation=tf.nn.relu),
    layers.Conv2D(64,kernel_size=[3,3],padding="same",activation=tf.nn.relu),
    layers.MaxPool2D(pool_size=[2,2],strides=2,padding="same"),

    # unit 2
    layers.Conv2D(128,kernel_size=[3,3],padding="same",activation=tf.nn.relu),
    layers.Conv2D(128,kernel_size=[3,3],padding="same",activation=tf.nn.relu),
    layers.MaxPool2D(pool_size=[2,2],strides=2,padding="same"),

    # unit 3
    layers.Conv2D(256,kernel_size=[3,3],padding="same",activation=tf.nn.relu),
    layers.Conv2D(256,kernel_size=[3,3],padding="same",activation=tf.nn.relu),
    layers.MaxPool2D(pool_size=[2,2],strides=2,padding="same"),

    #h和w慢慢缩小，channel也就是kernel的数量会慢慢增大，这样会慢慢缩小到一个3*3,7*7,1*1，但是其内部的信息量增加

    # unit 4
    layers.Conv2D(512,kernel_size=[3,3],padding="same",activation=tf.nn.relu),
    layers.Conv2D(512,kernel_size=[3,3],padding="same",activation=tf.nn.relu),
    layers.MaxPool2D(pool_size=[2,2],strides=2,padding="same"),

    # unit 5
    layers.Conv2D(512, kernel_size=[3, 3], padding="same", activation=tf.nn.relu),
    layers.Conv2D(512, kernel_size=[3, 3], padding="same", activation=tf.nn.relu),
    layers.MaxPool2D(pool_size=[2, 2], strides=2, padding="same")

    # 变成[b,1,1,512]的原因是max pool了5次？
]

#预处理
def preprocess(x,y):
    #->[0.1]
    x = tf.cast(x,dtype=tf.float32) / 255.
    y = tf.cast(y,dtype=tf.int32)
    return x,y

#获取数据
(x,y),(x_test,y_test) = datasets.cifar100.load_data()
y = tf.squeeze(y,axis=1)
y_test = tf.squeeze(y_test,axis=1)
print(x.shape,y.shape,x_test.shape,y_test.shape)


train_db = tf.data.Dataset.from_tensor_slices((x,y))
#打乱后预处理
train_db = train_db.shuffle(1000).map(preprocess).batch(64)

test_db = tf.data.Dataset.from_tensor_slices((x_test,y_test))
test_db = test_db.map(preprocess).batch(64)

#查看
sample=next(iter(train_db))
print('sample:',sample[0].shape,sample[1].shape,
      tf.reduce_min(sample[0]),tf.reduce_max(sample[0]))
#sample: (64, 32, 32, 3) (64, 1)
#  tf.Tensor(0.0, shape=(), dtype=float32) tf.Tensor(1.0, shape=(), dtype=float32)
#label需要从(64,1)改成(64,)；上面用tf.squeeze(y,axis=1)

def main():
    # [b,32,32,3] => [b,1,1,512]
    conv_net = Sequential(conv_layers)
    # x = tf.random.normal([4,32,32,3])
    # out = conv_net(x)
    # print(out.shape)
    # #(4, 1, 1, 512)
    fc_net = Sequential([
        layers.Dense(256, activation=tf.nn.relu),
        layers.Dense(128, activation=tf.nn.relu),
        layers.Dense(100, activation=None)
    ])

    conv_net.build(input_shape=[None, 32, 32, 3])
    # [b,1,1,512]需要变成[None,512]
    fc_net.build(input_shape=[None, 512])
    #设置优化器，lr太大会梯度消失
    optimizer = optimizers.Adam(lr=1e-4)

    #扩接，例[1,2]+[3,4] = [1,2,3,4]。将所有的网络的variable（卷积层与全连接层）拼接到一起
    variables = conv_net.trainable_variables + fc_net.trainable_variables

    for epoch in range(50):
        for step, (x, y) in enumerate(train_db):
            with tf.GradientTape() as tape:
                # [b,32,32,3] => [b,1,1,512]
                out = conv_net(x)
                #flatten平坦化 => [b,512]
                out = tf.reshape(out,[-1,512])
                #全连接层的输出,[b,512] => [b,100]
                logits = fc_net(out)
                #对标签y进行onehot编码，[b] => [b,100]
                y_onehot = tf.one_hot(y,depth=100)
                # compute loss，logits与真实值比较
                loss = tf.losses.categorical_crossentropy(y_onehot,logits,from_logits=True)
                #获得平均的loss
                loss = tf.reduce_mean(loss)

            grads = tape.gradient(loss,variables)
            #更新
            optimizer.apply_gradients(zip(grads,variables))

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

        #test
        total_num = 0
        total_correct = 0
        for x,y in test_db:
            #经过5个卷积层和全连接层
            out = conv_net(x)
            out = tf.reshape(out,[-1,512])
            logits = fc_net(out)
            #归一化，多分类结果以概率的形式展现
            prob = tf.nn.softmax(logits,axis=1)
            #取其中“概率”最大的
            pred = tf.argmax(prob,axis=1)
            #int64变成int32
            pred = tf.cast(pred,dtype=tf.int32)
            correct = tf.cast(tf.equal(pred,y),dtype=tf.int32)
            correct = tf.reduce_sum(correct)
            #每个step的图片数量（batch）加到total_num？
            total_num+=x.shape[0]
            total_correct += int(correct)

        acc= total_correct/total_num
        print(epoch,'acc:',acc)

if __name__ == "__main__":
    main()