resnet系列识别cifar100

resnet识别cifar100

resnet.py文件夹放入

import os

os.environ['TF_CPP_MIN_LOG_LEVEL']='2'
from tensorflow import keras
import tensorflow as tf
from tensorflow.keras import layers,optimizers,datasets,Sequential

class BasicBlack(layers.Layer):
    def __init__(self,filter_num,stride = 1):
        super(BasicBlack,self).__init__()

        self.conv1 = layers.Conv2D(filter_num,(3,3),strides=stride,padding='same')
        self.bn1 = layers.BatchNormalization()
        self.relu = layers.Activation('relu')

        self.conv2 = layers.Conv2D(filter_num, (3, 3), strides=1, padding='same')
        self.bn2 = layers.BatchNormalization()

        if(stride != 1):
            self.downsample = Sequential()
            self.downsample.add(layers.Conv2D(filter_num,(1,1),strides=stride))
        else:
            self.downsample = lambda x:x



    def call(self,inputs,training=None):
        out = self.conv1(inputs)
        out = self.bn1(out)
        out = self.relu(out)
        out = self.conv2(out)
        out = self.bn2(out)

        identity = self.downsample(inputs)

        output = layers.add([out,identity])
        output = self.relu(output)

        return output

class Restnet(keras.Model):

    def __init__(self,layer_dims,number_classes = 100):
        super(Restnet, 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')
                                ])
        self.layer1 = self.build_restblock(64,layer_dims[0])
        self.layer2 = self.build_restblock(128, layer_dims[1],stride=2)
        self.layer3 = self.build_restblock(256, layer_dims[2], stride=2)
        self.layer4 = self.build_restblock(512, layer_dims[3], stride=2)

        self.avgpool = layers.GlobalAveragePooling2D()
        self.fc = layers.Dense(number_classes)




    def call(self,inputs,training=None):
        x = self.stem(inputs,training=training)
        x = self.layer1(x,training = training)
        x = self.layer2(x,training = training)
        x = self.layer3(x,training = training)
        x = self.layer4(x,training = training)
        x = self.avgpool(x)
        x = self.fc(x)

        return x




    def build_restblock(self,filter_num,blocks,stride = 1):
        res_blocks = Sequential()
        res_blocks.add(BasicBlack(filter_num,stride))
        for _ in range(1,blocks):
            res_blocks.add(BasicBlack(filter_num, stride=1))

        return res_blocks



#resnet18网络参数
def resnet18():
    return Restnet([2,2,2,2])
    
#resnet34参数，其他resnet可以自己构造参数
def resnet34():
    return Restnet([3, 4, 6, 3])

train.py放入

import os

os.environ['TF_CPP_MIN_LOG_LEVEL']='2'
import tensorflow as tf
from tensorflow.keras import layers,optimizers,datasets,Sequential
from resnet import resnet18
tf.random.set_seed(2345)

#数据预处理函数
def preprocess(x,y):
    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,x_test.shape)

train_db = tf.data.Dataset.from_tensor_slices((x,y));
train_db = train_db.shuffle(1000).map(preprocess).batch(16);

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

sample = next(iter(train_db))
print('sample:',sample[0].shape,sample[1].shape)

sample = next(iter(test_db))
print('test_dbsample:',sample[0].shape,sample[1].shape)




def main():

    model = resnet18()
    model.build(input_shape = (None,32,32,3))
    optimizer = optimizers.Adam(lr=1e-3)

    for epoch in range(50):

        for step, (x, y) in enumerate(train_db):
            #print(x.shape,y.shape)
            with tf.GradientTape() as tape:

                logits = model(x)

                y_hot = tf.one_hot(y,depth=100)
                #loss
                loss = tf.losses.categorical_crossentropy(y_hot,logits,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))


        total_sum = 0
        total_currect = 0
        for x,y in test_db:


            logits  = model(x)
            prob = tf.nn.softmax(logits,axis=1)
            pred = tf.argmax(prob,axis=1)
            pred = tf.cast(pred ,dtype=tf.int32)


            correct = tf.cast(tf.equal(pred,y),dtype=tf.int32)
            correct = tf.reduce_sum(correct)
            total_sum += x.shape[0]
            total_currect +=int(correct)


        acc = total_currect / total_sum

        print('acc: ',acc)


if __name__ == '__main__':
    main()

完结撒花！！！