第五讲 卷积神经网络 VGG16 cifar10

import tensorflow as tf
import os
import numpy as np
from matplotlib import pyplot as plt
from tensorflow.keras.layers import Conv2D, BatchNormalization, Activation, MaxPool2D, Dropout, Flatten, Dense
from tensorflow.keras import Model


np.set_printoptions(threshold=np.inf)

cifar10 = tf.keras.datasets.cifar10
(x_train, y_train), (x_test, y_test) = cifar10.load_data()
x_train, x_test = x_train/255.0, x_test/255.0


class VGG16(Model):
  def __init__(self):
    super(VGG16, self).__init__()
    self.c1 = Conv2D(filters=64, kernel_size=(3, 3), padding='same')
    self.b1 = BatchNormalization()
    self.a1 = Activation('relu')
    self.c2 = Conv2D(filters=64, kernel_size=(3, 3), padding='same')
    self.b2 = BatchNormalization()
    self.a2 = Activation('relu')
    self.p1 = MaxPool2D(pool_size = (2, 2), strides=2, padding='same')
    self.d1 = Dropout(0.2)

    self.c3 = Conv2D(filters=128, kernel_size=(3, 3), padding='same')
    self.b3 = BatchNormalization()
    self.a3 = Activation('relu')
    self.c4 = Conv2D(filters=128, kernel_size=(3, 3), padding='same')
    self.b4 = BatchNormalization()
    self.a4 = Activation('relu')
    self.p2 = MaxPool2D(pool_size=(2,2), strides=2, padding='same')
    self.d2 = Dropout(0.2)

    self.c5 = Conv2D(filters=256, kernel_size=(3, 3), padding='same')
    self.b5 = BatchNormalization()
    self.a5 = Activation('relu')
    self.c6 = Conv2D(filters=256, kernel_size=(3, 3), padding='same')
    self.b6 = BatchNormalization()
    self.a6 = Activation('relu')
    self.c7 = Conv2D(filters=256, kernel_size=(3, 3), padding='same')
    self.b7 = BatchNormalization()
    self.a7 = Activation('relu')
    self.p3 = MaxPool2D(pool_size=(2, 2), strides=2, padding='same')
    self.d3 = Dropout(0.2)

    self.c8 = Conv2D(filters=512, kernel_size=(3, 3), padding='same')
    self.b8 = BatchNormalization()
    self.a8 = Activation('relu')
    self.c9 = Conv2D(filters=512, kernel_size=(3, 3), padding='same')
    self.b9 = BatchNormalization()
    self.a9 = Activation('relu')
    self.c10 = Conv2D(filters=512, kernel_size=(3, 3), padding='same')
    self.b10 = BatchNormalization()
    self.a10 = Activation('relu')
    self.p4 = MaxPool2D(pool_size=(2, 2), strides=2, padding='same')
    self.d4 = Dropout(0.2)

    self.c11 = Conv2D(filters=512, kernel_size=(3, 3), padding='same')
    self.b11 = BatchNormalization()
    self.a11 = Activation('relu')
    self.c12 = Conv2D(filters=512, kernel_size=(3, 3), padding='same')
    self.b12 = BatchNormalization()
    self.a12 = Activation('relu')
    self.c13 = Conv2D(filters=512, kernel_size=(3, 3), padding='same')
    self.b13 = BatchNormalization()
    self.a13 = Activation('relu')
    self.p5 = MaxPool2D(pool_size=(2,2), strides=2, padding='same')
    self.d5 = Dropout(0.2)

    self.flatten = Flatten()
    self.f1 = Dense(512, activation='relu')
    self.d6 = Dropout(0.2)
    self.f2 = Dense(512, activation='relu')
    self.d7 = Dropout(0.7)
    self.f3 = Dense(10, activation='softmax')

  def call(self, x):
    x = self.c1(x)
    x = self.b1(x)
    x = self.a1(x)
    x = self.c2(x)
    x = self.b2(x)
    x = self.a2(x)
    x = self.p1(x)
    x = self.d1(x)

    x = self.c3(x)
    x = self.b3(x)
    x = self.a3(x)
    x = self.c4(x)
    x = self.b4(x)
    x = self.a4(x)
    x = self.p2(x)
    x = self.d2(x)

    x = self.c5(x)
    x = self.b5(x)
    x = self.a5(x)
    x = self.c6(x)
    x = self.b6(x)
    x = self.a6(x)
    x = self.c7(x)
    x = self.b7(x)
    x = self.a7(x)
    x = self.p3(x)
    x = self.d3(x)

    x = self.c8(x)
    x = self.b8(x)
    x = self.a8(x)
    x = self.c9(x)
    x = self.b9(x)
    x = self.a9(x)
    x = self.c10(x)
    x = self.b10(x)
    x = self.a10(x)
    x = self.p4(x)
    x = self.d4(x)

    x = self.c11(x)
    x = self.b11(x)
    x = self.a11(x)
    x = self.c12(x)
    x = self.b12(x)
    x = self.a12(x)
    x = self.c13(x)
    x = self.b13(x)
    x = self.a13(x)
    x = self.p5(x)
    x = self.d5(x)

    x = self.flatten(x)
    x = self.f1(x)
    x = self.d6(x)
    x = self.f2(x)
    x = self.d7(x)
    y = self.f3(x)
    return y


model = VGG16()

model.compile(optimizer='adam', 
              loss = tf.keras.losses.SparseCategoricalCrossentropy(from_logits=False),
              metrics=['sparse_categorical_accuracy'])

checkpoint_save_path = "./checkpoint/VGG16.ckpt"
if os.path.exists(checkpoint_save_path + '.index'):
  print('------------------------load the model---------------------')
  model.load_weights(checkpoint_save_path)

cp_callback = tf.keras.callbacks.ModelCheckpoint(filepath=checkpoint_save_path,
                                                 save_weights_only=True,
                                                 save_best_only=True)


history = model.fit(x_train, y_train, batch_size=128, epochs=50, validation_data=(x_test, y_test),validation_freq=1, callbacks=[cp_callback])

model.summary()


with open('./weights.txt', 'w') as f:
  for v in model.trainable_variables:
    f.write(str(v.name) + '\n')
    f.write(str(v.shape) + '\n')
    f.write(str(v.numpy()) + '\n')



def plot_acc_loss_curve(history):
    # 显示训练集和验证集的acc和loss曲线
    from matplotlib import pyplot as plt
    acc = history.history['sparse_categorical_accuracy']
    val_acc = history.history['val_sparse_categorical_accuracy']
    loss = history.history['loss']
    val_loss = history.history['val_loss']
    
    plt.figure(figsize=(15, 5))
    plt.subplot(1, 2, 1)
    plt.plot(acc, label='Training Accuracy')
    plt.plot(val_acc, label='Validation Accuracy')
    plt.title('Training and Validation Accuracy')
    plt.legend()
    #plt.grid()
    
    plt.subplot(1, 2, 2)
    plt.plot(loss, label='Training Loss')
    plt.plot(val_loss, label='Validation Loss')
    plt.title('Training and Validation Loss')
    plt.legend()
    #plt.grid()
    plt.show()

plot_acc_loss_curve(history)

 

 

以下代码源自dive into DL T2.0, 运行时间较长，建议在colab上运行。

 

import numpy as np
import tensorflow as tf
print(tf.__version__)


for gpu in tf.config.experimental.list_physical_devices('GPU'):
  tf.config.experimental.set_memory_growth(gpu, True)


def vgg_block(num_convs, num_channels):
  blk = tf.keras.models.Sequential()
  for _ in range(num_convs):
    blk.add(tf.keras.layers.Conv2D(num_channels, kernel_size=3, padding='same', activation='relu'))
  
    blk.add(tf.keras.layers.MaxPool2D(pool_size=2, strides=2))
    return blk


conv_arch = ((1, 64), (1, 128), (2, 256), (2, 512), (2, 512))


def vgg(conv_arch):
  net = tf.keras.models.Sequential()
  for (num_convs, num_channels) in conv_arch:
    net.add(vgg_block(num_convs, num_channels))
  net.add(tf.keras.models.Sequential([
          tf.keras.layers.Flatten(),
          tf.keras.layers.Dense(4096, activation='relu'),
          tf.keras.layers.Dropout(0.5),
          tf.keras.layers.Dense(4096, activation='relu'),
          tf.keras.layers.Dropout(0.5),
          tf.keras.layers.Dense(10, activation='softmax')
  ]))
  return net

net = vgg(conv_arch)


X = tf.random.uniform((1, 224, 224, 1))
for blk in net.layers:
  X = blk(X)
  print(blk.name, 'output shape:\t', X.shape)


ratio = 4
small_conv_arch = [(pair[0], pair[1] // ratio) for pair in conv_arch]
net = vgg(small_conv_arch)


class DataLoader():
  def __init__(self):
    fashion_mnist = tf.keras.datasets.fashion_mnist
    (self.train_images, self.train_labels), (self.test_images, self.test_labels) = fashion_mnist.load_data()
    self.train_images = np.expand_dims(self.train_images.astype(np.float32)/255.0, axis=-1)
    self.test_images = np.expand_dims(self.test_images.astype(np.float32)/255.0, axis=-1)
    self.train_labels = self.train_labels.astype(np.int32)
    self.test_labels = self.test_labels.astype(np.float32)
    self.num_train, self.num_test = self.train_images.shape[0], self.test_images.shape[0]
  
  def get_batch_train(self, batch_size):
    index = np.random.randint(0, np.shape(self.train_images)[0], batch_size)
    #need to resize images to (224, 224)
    resized_images = tf.image.resize_with_pad(self.train_images[index], 224, 224,)
    return resized_images.numpy(), self.train_labels[index]
  
  def get_batch_test(self, batch_size):
    index = np.random.randint(0, np.shape(self.test_images)[0], batch_size)
    #need to resize images to (224, 224)
    resized_images = tf.image.resize_with_pad(self.test_images[index], 224, 224,)
    return resized_images.numpy(), self.test_labels[index]


batch_size = 128
dataLoader = DataLoader()
x_batch, y_batch = dataLoader.get_batch_train(batch_size)
print('x_batch shape:', x_batch.shape, 'y_batch shape:', y_batch.shape)


batch_size = 128
dataLoader = DataLoader()
x_batch, y_batch = dataLoader.get_batch_train(batch_size)
print('x_batch shape:', x_batch.shape, 'y_batch shape:', y_batch.shape)


def train_vgg():
  #net.load_weights('5.7_vgg_weights.h5)
  epoch = 5
  num_iter = dataLoader.num_train // batch_size
  for e in range(epoch):
    for n in range(num_iter):
      x_batch, y_batch = dataLoader.get_batch_train(batch_size)
      net.fit(x_batch, y_batch)
      if n%50 == 0:
        net.save_weights('5.7_vgg_weights.h5')

optimizer = tf.keras.optimizers.SGD(learning_rate = 0.05, momentum=0.0, nesterov=False)

net.compile(optimizer=optimizer, 
            loss='sparse_categorical_crossentropy',
            metrics=['accuracy'])

x_batch, y_batch = dataLoader.get_batch_train(batch_size)
net.fit(x_batch, y_batch)
train_vgg()


net.load_weights('5.7_vgg_weights.h5')

x_test, y_test = dataLoader.get_batch_test(2000)
net.evaluate(x_test, y_test, verbose=2)