【程序】使用keras实现以下模型：LeNet5、AlexNet、VggNet19、ResNet34

keras实现LeNet5：

import tensorflow as tf
from tensorflow import keras

import os
os.environ["CUDA_VISIBLE_DEVICES"] = "2"

# 使用tf.data进行数据馈送，此为参考示例
def parse_function(example_proto):
    features = {
        'label' : tf.FixedLenFeature([], tf.int64),
        'img_raw' : tf.FixedLenFeature([], tf.string)
    }
    parsed_features = tf.parse_single_example(example_proto, features)
    img = tf.decode_raw(parsed_features['img_raw'], tf.uint8)
    img = tf.reshape(img, [224, 224, 3])
    img = tf.cast(img, tf.float32) / 255
    label = tf.one_hot(parsed_features['label'], depth= 2)
    #label = to_categorical(parsed_features['label'], num_classes= 8)
    return img, label
dataset = tf.data.TFRecordDataset(r"C:\Users\12394\PycharmProjects\Chest X-Ray Automatic Identification\dataset\train.tfrecords")
dataset = dataset.map(parse_function)
dataset = dataset.repeat()
dataset = dataset.shuffle(buffer_size= 5).batch(4)

# Define the input layer
inputs = keras.Input(shape = [224, 224, 3])
# Define the converlutional layer 1
conv1 = keras.layers.Conv2D(filters= 6, kernel_size= [5, 5], strides= (1, 1), padding= 'same',activation= keras.activations.relu,use_bias=True)(inputs)
# Define the pooling layer 1
pooling1 = keras.layers.MaxPooling2D(pool_size= (2, 2), strides= (2, 2), padding= 'same')(conv1)
# Define the converlutional layer 2
conv2 = keras.layers.Conv2D(filters= 16, kernel_size= (5, 5), strides= (1, 1), padding= 'same', activation= keras.activations.relu, use_bias=True)(pooling1)
# Define the pooling layer 2
pooling2 = keras.layers.MaxPooling2D(pool_size= (2, 2), strides= (2, 2), padding= 'valid')(conv2)
# Define the converlutional layer 3
conv3 = keras.layers.Conv2D(filters= 120, kernel_size= (5, 5), strides= (1, 1), padding= 'same', activation= keras.activations.relu, use_bias=True)(pooling2)
# Define the fully connected layer

flatten = keras.layers.Flatten()(conv3)
connected = keras.layers.Dense(80, activation= keras.activations.relu, use_bias=True)(flatten)

predictions = keras.layers.Dense(2, activation= 'softmax', use_bias=True)(connected)

# 基于Model方法实现模型
model = keras.Model(inputs= inputs, outputs = predictions)
# 编译模型
model.compile(optimizer= tf.train.AdamOptimizer(0.01),
              loss= keras.losses.categorical_crossentropy,
              metrics= ['accuracy'])
# 训练配置，仅供参考
model.fit(dataset, epochs = 5, steps_per_epoch= 4442)
model.save('模型文件地址')

keras实现AlexNet：

import tensorflow as tf
from tensorflow import keras

# 使用tf.data进行数据馈送，此为参考示例
def parse_function(example_proto):
    features = {
        'label' : tf.FixedLenFeature([], tf.int64),
        'img_raw' : tf.FixedLenFeature([], tf.string)
    }
    parsed_features = tf.parse_single_example(example_proto, features)
    img = tf.decode_raw(parsed_features['img_raw'], tf.uint8)
    img = tf.reshape(img, [224, 224, 3])
    img = tf.cast(img, tf.float32) / 255
    label = tf.one_hot(parsed_features['label'], depth= 2)
    #label = to_categorical(parsed_features['label'], num_classes= 8)
    return img, label
dataset = tf.data.TFRecordDataset(r"C:\Users\12394\PycharmProjects\Chest X-Ray Automatic Identification\dataset\train.tfrecords")
dataset = dataset.map(parse_function)
dataset = dataset.repeat()
dataset = dataset.shuffle(buffer_size= 5).batch(4)


# Define the input layer
inputs = keras.Input(shape = [150, 150, 3])

# Define the converlutional layer 1
conv1 = keras.layers.Conv2D(filters= 96, kernel_size= [11, 11], strides= [4, 4], activation= keras.activations.relu, use_bias= True, padding= 'valid')(inputs)


# Define the standardization layer 1
stand1 = keras.layers.BatchNormalization(axis= 1)(conv1)

# Define the pooling layer 1
pooling1 = keras.layers.MaxPooling2D(pool_size= [3, 3], strides= [2, 2], padding= 'valid')(stand1)

# Define the converlutional layer 2
conv2 = keras.layers.Conv2D(filters= 256, kernel_size= [5, 5], strides= [1, 1], activation= keras.activations.relu, use_bias= True, padding= 'valid')(pooling1)

# Define the standardization layer 2
stand2 = keras.layers.BatchNormalization(axis= 1)(conv2)

# Defien the pooling layer 2
pooling2 = keras.layers.MaxPooling2D(pool_size= [3, 3], strides= [2, 2], padding= 'valid')(stand2)

# Define the converlutional layer 3
conv3 = keras.layers.Conv2D(filters= 384, kernel_size= [3, 3], strides= [1, 1], activation= keras.activations.relu, use_bias= True, padding= 'valid')(pooling2)

# Define the converlutional layer 4
conv4 = keras.layers.Conv2D(filters= 384, kernel_size= [3, 3], strides= [1, 1], activation= keras.activations.relu, use_bias= True, padding= 'valid')(conv3)

# Define the converlutional layer 5
conv5 = keras.layers.Conv2D(filters= 256, kernel_size= [3, 3], strides= [1, 1], activation= keras.activations.relu, use_bias= True, padding= 'valid')(conv4)

# Defien the pooling layer 3
pooling3 = keras.layers.MaxPooling2D(pool_size= [3, 3], strides= [2, 2], padding= 'valid')(conv5)

# Define the fully connected layer
flatten = keras.layers.Flatten()(pooling3)

fc1 = keras.layers.Dense(4096, activation= keras.activations.relu, use_bias= True)(flatten)
drop1 = keras.layers.Dropout(0.5)(fc1)

fc2 = keras.layers.Dense(4096, activation= keras.activations.relu, use_bias= True)(drop1)
drop2 = keras.layers.Dropout(0.5)(fc2)

fc3 = keras.layers.Dense(1000, activation= keras.activations.softmax, use_bias= True)(drop2)

# 基于Model方法构建模型
model = keras.Model(inputs= inputs, outputs = fc3)
# 编译模型
model.compile(optimizer= tf.train.AdamOptimizer(0.01),
              loss= keras.losses.categorical_crossentropy,
              metrics= ['accuracy'])
# 训练配置，仅供参考
model.fit(dataset, epochs = 5, steps_per_epoch= 4442)
model.save('模型文件地址')

 keras实现VggNet19:

import tensorflow as tf
from tensorflow import keras

# 使用tf.data进行数据馈送，此为参考示例
def parse_function(example_proto):
    features = {
        'label' : tf.FixedLenFeature([], tf.int64),
        'img_raw' : tf.FixedLenFeature([], tf.string)
    }
    parsed_features = tf.parse_single_example(example_proto, features)
    img = tf.decode_raw(parsed_features['img_raw'], tf.uint8)
    img = tf.reshape(img, [224, 224, 3])
    img = tf.cast(img, tf.float32) / 255
    label = tf.one_hot(parsed_features['label'], depth= 2)
    #label = to_categorical(parsed_features['label'], num_classes= 8)
    return img, label
dataset = tf.data.TFRecordDataset(r"C:\Users\12394\PycharmProjects\Chest X-Ray Automatic Identification\dataset\train.tfrecords")
dataset = dataset.map(parse_function)
dataset = dataset.repeat()
dataset = dataset.shuffle(buffer_size= 5).batch(4)

# Define the input layer
inputs = keras.Input(shape = [150, 150, 3])

# Define the converlutional layer 1
conv1_1 = keras.layers.Conv2D(64, kernel_size= [3, 3], strides= [1, 1], activation= keras.activations.relu, use_bias= True, padding= 'same')(inputs)
conv1_2 = keras.layers.Conv2D(64, kernel_size= [3, 3], strides= [1, 1], activation= keras.activations.relu, use_bias= True, padding= 'same')(conv1_1)
pooling1 = keras.layers.MaxPooling2D(pool_size= [2, 2], strides= [2, 2], padding= 'same')(conv1_2)

# Define the converlutional layer 2
conv2_1 = keras.layers.Conv2D(128, kernel_size= [3, 3], strides= [1, 1], activation= keras.activations.relu, use_bias= True, padding= 'same')(pooling1)
conv2_2 = keras.layers.Conv2D(128, kernel_size= [3, 3], strides= [1, 1], activation= keras.activations.relu, use_bias= True, padding= 'same')(conv2_1)
pooling2 = keras.layers.MaxPooling2D(pool_size= [2, 2], strides= [2, 2], padding= 'same')(conv2_2)

# Define the converlutional layer 3
conv3_1 = keras.layers.Conv2D(256, kernel_size= [3, 3], strides= [1, 1], activation= keras.activations.relu, use_bias= True, padding= 'same')(pooling2)
conv3_2 = keras.layers.Conv2D(256, kernel_size= [3, 3], strides= [1, 1], activation= keras.activations.relu, use_bias= True, padding= 'same')(conv3_1)
conv3_3 = keras.layers.Conv2D(256, kernel_size= [3, 3], strides= [1, 1], activation= keras.activations.relu, use_bias= True, padding= 'same')(conv3_2)
conv3_4 = keras.layers.Conv2D(256, kernel_size= [3, 3], strides= [1, 1], activation= keras.activations.relu, use_bias= True, padding= 'same')(conv3_3)
pooling3 = keras.layers.MaxPooling2D(pool_size= [2, 2], strides= [2, 2], padding= 'same')(conv3_4)

# Define the converlutional layer 4
conv4_1 = keras.layers.Conv2D(512, kernel_size= [3, 3], strides= [1, 1], activation= keras.activations.relu, use_bias= True, padding= 'same')(pooling3)
conv4_2 = keras.layers.Conv2D(512, kernel_size= [3, 3], strides= [1, 1], activation= keras.activations.relu, use_bias= True, padding= 'same')(conv4_1)
conv4_3 = keras.layers.Conv2D(512, kernel_size= [3, 3], strides= [1, 1], activation= keras.activations.relu, use_bias= True, padding= 'same')(conv4_2)
conv4_4 = keras.layers.Conv2D(512, kernel_size= [3, 3], strides= [1, 1], activation= keras.activations.relu, use_bias= True, padding= 'same')(conv4_3)
pooling4 = keras.layers.MaxPooling2D(pool_size= [2, 2], strides= [2, 2], padding= 'same')(conv4_4)

# Define the converlutional layer 5
conv5_1 = keras.layers.Conv2D(512, kernel_size= [3, 3], strides= [1, 1], activation= keras.activations.relu, use_bias= True, padding= 'same')(pooling4)
conv5_2 = keras.layers.Conv2D(512, kernel_size= [3, 3], strides= [1, 1], activation= keras.activations.relu, use_bias= True, padding= 'same')(conv5_1)
conv5_3 = keras.layers.Conv2D(512, kernel_size= [3, 3], strides= [1, 1], activation= keras.activations.relu, use_bias= True, padding= 'same')(conv5_2)
conv5_4 = keras.layers.Conv2D(512, kernel_size= [3, 3], strides= [1, 1], activation= keras.activations.relu, use_bias= True, padding= 'same')(conv5_3)
pooling5 = keras.layers.MaxPooling2D(pool_size= [2, 2], strides= [2, 2], padding= 'same')(conv5_4)

flatten = keras.layers.Flatten()(pooling5)

# Defien the fully connected layer
fc1 = keras.layers.Dense(4096, activation= keras.activations.relu, use_bias= True)(flatten)

fc2 = keras.layers.Dense(4096, activation= keras.activations.relu, use_bias= True)(fc1)

fc3 = keras.layers.Dense(1000, activation= keras.activations.relu, use_bias= True)(fc2)

prediction = keras.layers.Dense(2, activation= keras.activations.softmax, use_bias= True)(fc3)
# 基于Model方法构建模型
model = keras.Model(inputs= inputs, outputs = prediction)

# 编译模型
model.compile(optimizer= tf.train.AdamOptimizer(0.01),
              loss= keras.losses.categorical_crossentropy,
              metrics= ['accuracy'])
# 训练配置，仅供参考
model.fit(dataset, epochs = 5, steps_per_epoch= 4442)
model.save('模型文件地址')

 keras实现ResNet34：

（1）模型结构

ResNet-34的模型结构如下：

from keras.layers import Conv2D, BatchNormalization, Dense, Flatten,\
    MaxPooling2D, AveragePooling2D, ZeroPadding2D, Input, add
from keras.models import Model
from keras.utils import plot_model
from keras.metrics import top_k_categorical_accuracy

def conv_block(inputs, 
        neuron_num, 
        kernel_size,  
        use_bias, 
        padding= 'same',
        strides= (1, 1),
        with_conv_short_cut = False):
    conv1 = Conv2D(
        neuron_num,
        kernel_size = kernel_size,
        activation= 'relu',
        strides= strides,
        use_bias= use_bias,
        padding= padding
    )(inputs)
    conv1 = BatchNormalization(axis = 1)(conv1)

    conv2 = Conv2D(
        neuron_num,
        kernel_size= kernel_size,
        activation= 'relu',
        use_bias= use_bias,
        padding= padding)(conv1)
    conv2 = BatchNormalization(axis = 1)(conv2)

    if with_conv_short_cut:
        inputs = Conv2D(
            neuron_num, 
            kernel_size= kernel_size,
            strides= strides,
            use_bias= use_bias,
            padding= padding
            )(inputs)
        return add([inputs, conv2])

    else:
        return add([inputs, conv2])

inputs = Input(shape= [224, 224, 3])
x = ZeroPadding2D((3, 3))(inputs)

# Define the converlutional block 1
x = Conv2D(64, kernel_size= (7, 7), strides= (2, 2), padding= 'valid')(x)
x = BatchNormalization(axis= 1)(x)
x = MaxPooling2D(pool_size= (3, 3), strides= (2, 2), padding= 'same')(x)

# Define the converlutional block 2
x = conv_block(x, neuron_num= 64, kernel_size= (3, 3), use_bias= True)
x = conv_block(x, neuron_num= 64, kernel_size= (3, 3), use_bias= True)
x = conv_block(x, neuron_num= 64, kernel_size= (3, 3), use_bias= True)

# Define the converlutional block 3
x = conv_block(x, neuron_num= 128, kernel_size= (3, 3), use_bias= True, strides= (2, 2), with_conv_short_cut= True)
x = conv_block(x, neuron_num= 128, kernel_size= (3, 3), use_bias= True)
x = conv_block(x, neuron_num= 128, kernel_size= (3, 3), use_bias= True)

# Define the converlutional block 4
x = conv_block(x, neuron_num= 256, kernel_size= (3, 3), use_bias= True, strides= (2, 2), with_conv_short_cut= True)
x = conv_block(x, neuron_num= 256, kernel_size= (3, 3), use_bias= True)
x = conv_block(x, neuron_num= 256, kernel_size= (3, 3), use_bias= True)
x = conv_block(x, neuron_num= 256, kernel_size= (3, 3), use_bias= True)
x = conv_block(x, neuron_num= 256, kernel_size= (3, 3), use_bias= True)
x = conv_block(x, neuron_num= 256, kernel_size= (3, 3), use_bias= True)

# Define the converltional block 5
x = conv_block(x, neuron_num= 512, kernel_size= (3, 3), use_bias= True, strides= (2, 2), with_conv_short_cut= True)
x = conv_block(x, neuron_num= 512, kernel_size= (3, 3), use_bias= True)
x = conv_block(x, neuron_num= 512, kernel_size= (3, 3), use_bias= True)
x = AveragePooling2D(pool_size=(7, 7))(x)
x = Flatten()(x)
x = Dense(8, activation='softmax')(x)

model = Model(inputs= inputs, outputs= x)
# Print the detail of the model
model.summary()
# compile the model 
model.compile(optimizer='adam', 
        loss='categorical_crossentropy', 
        metrics=['acc',top_k_categorical_accuracy])
plot_model(model, to_file= 'C:/Users/12394/PycharmProjects/Keras/model_ResNet-34.png')

 注：